Wayzata's Best of Shareware PC/Windows 1

home *** CD-ROM | disk | FTP | other *** search

/ Wayzata's Best of Shareware PC/Windows 1 / Wayzata's Best of Shareware for PC-Windows - Release 1 - Wayzata Technology (1993).iso / mac / DOS / PROGRAMG / REXL211A / REXLMAIN.DOC < prev next >

Wrap

Text File | 1992-08-17 | 218KB | 5,662 lines

RExL Version 2.11 A Rule-based Applications Development Environment From The Software Loft, Kiemar House, Shanakiel Road, Cork City, Ireland. Tel: [+353] 21-302511 Fax: [+353] 21-343562 Internet: softloft@iruccvax.ucc.ie Compuserve: 100042,1237 -- Part I -- The Main Manual -- _______ ____|__ | (R) --| | |------------------- | ____|__ | Association of | | |_| Shareware |__| o | Professionals -----| | |--------------------- |___|___| MEMBER This program is produced by a member of the Association of Shareware Professionals (ASP). ASP wants to make sure that the shareware principle works for you. If you are unable to resolve a shareware-related problem with an ASP member by contacting the member directly, ASP may be able to help. The ASP Ombudsman can help you resolve a dispute or problem with an ASP member, but does not provide technical support for members' products. Please write to the ASP Ombudsman at 545 Grover Road, Muskegon, MI 49442- 9427 or send a Compuserve message via CompuServe Mail to ASP Ombudsman 70007,3536. o Information in this document is subject to change without notice and does not represent a commitment on the part of The Software Loft. The software described in this manual may be used and copied within the terms of the license agreement. Turbo C, Turbo Pascal and Sidekick are registered trademarks of Borland International. dBase III+ and dBase are registered trademarks of Ashton-Tate. (C) Copyright, The Software Loft, 1992. All rights reserved. If you have any difficulties, please contact us at the address above. Contents Chapter 1 Introduction 3 1.1 What is RExL . . . . . . . . . . . . . . 3 1.2 System requirements . . . . . . . . . . 4 1.3 Installation . . . . . . . . . . . . . . 4 1.4 Features . . . . . . . . . . . . . . . . 5 1.4.1 Editor . . . . . . . . . . . . . . 5 1.4.2 Runtime-Debugger . . . . . . . . . 6 1.4.3 Language . . . . . . . . . . . . . 6 1.5 The Manual . . . . . . . . . . . . . . . 7 Chapter 2 Language 9 2.1 Variables . . . . . . . . . . . . . . . 9 2.2 Constants . . . . . . . . . . . . . . 10 2.3 Arrays . . . . . . . . . . . . . . . . 11 2.4 Operators . . . . . . . . . . . . . . 12 2.4.1 Mathematical Operators . . . . . 12 2.4.2 Comparison Operators . . . . . . 14 2.5 Functions . . . . . . . . . . . . . . 14 2.6 Expressions . . . . . . . . . . . . . 16 2.7 Assignments . . . . . . . . . . . . . 18 2.8 Statements . . . . . . . . . . . . . . 19 2.9 Inference . . . . . . . . . . . . . . 19 2.10 Rules and Execution . . . . . . . . . 20 2.11 Subrules . . . . . . . . . . . . . . 21 2.12 Rule Modifiers . . . . . . . . . . . 22 2.12.1 BackTo . . . . . . . . . . . . . 23 2.12.2 Not . . . . . . . . . . . . . . 23 2.12.3 While . . . . . . . . . . . . . 23 2.12.4 Multi . . . . . . . . . . . . . 24 2.12.5 Single . . . . . . . . . . . . . 24 2.12.6 Zap . . . . . . . . . . . . . . 24 2.13 Other Modifiers . . . . . . . . . . . 24 Chapter 3 Quick Start 27 3.1 Introduction . . . . . . . . . . . . . 27 3.2 Creating an Application . . . . . . . 28 3.3 Running the Application . . . . . . . 29 3.4 Expanding the Application . . . . . . 30 i 3.5 Debugging the Application . . . . . . 32 Chapter 4 The Editor 35 4.1 Introduction . . . . . . . . . . . . . 35 4.2 Interface Conventions . . . . . . . . 36 4.3 Editor Basics . . . . . . . . . . . . 39 4.3.1 File menu . . . . . . . . . . . . 41 4.3.2 Edit menu . . . . . . . . . . . . 43 4.3.3 Run menu . . . . . . . . . . . . 43 4.3.4 Lists menu . . . . . . . . . . . 44 4.3.5 Options menu . . . . . . . . . . 46 4.3.6 Import menu . . . . . . . . . . . 47 4.4 Using the Editor . . . . . . . . . . . 49 4.4.1 Entering Statements . . . . . . . 50 4.4.2 Entering Rules . . . . . . . . . 51 4.4.3 Entering Screens . . . . . . . . 52 4.5 Editor Lists . . . . . . . . . . . . . 52 4.5.1 Reference List . . . . . . . . . 53 4.5.2 Rule List . . . . . . . . . . . . 53 4.5.3 Screen List . . . . . . . . . . . 53 4.5.4 Unused Rule List . . . . . . . . 54 4.5.5 Unused Screen List . . . . . . . 54 4.5.6 Variable List . . . . . . . . . . 54 4.5.7 Function List . . . . . . . . . . 55 4.6 Other Functions . . . . . . . . . . . 56 4.6.1 Graphic Rule Display . . . . . . 56 4.6.2 Miscellaneous keystrokes . . . . 57 4.6.2.1 Cut and paste . . . . . . . 57 4.6.2.2 Editing keys . . . . . . . . 57 4.6.2.3 Other keys . . . . . . . . . 58 Chapter 5 Screens in RExL 59 5.1 Introduction . . . . . . . . . . . . . 59 5.2 Fields . . . . . . . . . . . . . . . . 60 5.2.1 Introduction . . . . . . . . . . 60 5.2.1.1 Field Properties . . . . . . 60 5.2.2 Output Fields . . . . . . . . . . 61 5.2.3 Input Fields . . . . . . . . . . 61 5.2.4 Toggle List Fields . . . . . . . 61 5.2.5 Check Box Fields . . . . . . . . 62 5.2.6 Radio Button Fields . . . . . . . 62 5.2.7 Menu Fields . . . . . . . . . . . 63 5.3 Screen Types . . . . . . . . . . . . . 63 5.3.1 Dialog Screen . . . . . . . . . . 65 5.3.2 Display Screen . . . . . . . . . 65 5.3.3 Help Screen . . . . . . . . . . . 66 5.3.4 Menu Screen . . . . . . . . . . . 66 5.3.5 Print Screen . . . . . . . . . . 67 ii 5.3.6 Subscreens . . . . . . . . . . . 67 Chapter 6 Using the Screen Designer 69 6.1 Starting the Screen Designer . . . . . 69 6.2 Basic Design . . . . . . . . . . . . . 70 6.3 Fields in the Screen Designer . . . . 71 6.3.0.1 Output . . . . . . . . . . . 73 6.3.0.2 Input . . . . . . . . . . . 73 6.3.0.3 Toggle . . . . . . . . . . . 73 6.3.0.4 Check . . . . . . . . . . . 74 6.3.0.5 Radio . . . . . . . . . . . 74 6.3.0.6 Menu . . . . . . . . . . . . 74 6.4 Block Operations . . . . . . . . . . . 75 6.4.1 Block Painting . . . . . . . . . 75 6.4.2 Align . . . . . . . . . . . . . . 76 6.4.3 Box . . . . . . . . . . . . . . . 76 6.4.4 Delete . . . . . . . . . . . . . 77 6.4.5 Move . . . . . . . . . . . . . . 77 6.4.6 Copy . . . . . . . . . . . . . . 78 6.4.7 Fill . . . . . . . . . . . . . . 78 6.4.8 Save . . . . . . . . . . . . . . 79 6.4.9 Under shadow . . . . . . . . . . 79 6.5 Sub-screens . . . . . . . . . . . . . 79 6.6 Field control menu . . . . . . . . . . 80 6.6.0.1 Active color . . . . . . . . 81 6.6.0.2 Inactive color . . . . . . . 81 6.6.0.3 Delete . . . . . . . . . . . 82 6.6.0.4 Expression . . . . . . . . . 82 6.6.0.5 Recalc . . . . . . . . . . . 82 6.6.0.6 Justify . . . . . . . . . . 82 6.6.0.7 Width . . . . . . . . . . . 82 6.6.0.8 Necessary . . . . . . . . . 83 6.6.0.9 Precision . . . . . . . . . 83 6.6.0.10 Validation . . . . . . . . 83 6.7 Miscellaneous Functions . . . . . . . 83 6.7.0.1 Changing Field Types . . . . 83 6.7.0.2 Field Utility Keys . . . . . 84 6.7.0.3 Line Drawing . . . . . . . . 84 6.7.0.4 Other Editing Keys . . . . . 86 6.7.0.5 Lists in the Screen Designer . . . . . . . . . . 86 6.7.0.6 Miscellaneous Keys . . . . . 87 Chapter 7 The Runtime-Debugger 89 7.1 Introduction . . . . . . . . . . . . . 89 7.2 Debugger Basics . . . . . . . . . . . 89 7.2.1 File menu . . . . . . . . . . . . 91 7.2.2 Debug menu . . . . . . . . . . . 91 iii 7.2.3 Lists menu . . . . . . . . . . . 92 7.2.4 Options menu . . . . . . . . . . 94 7.3 Using the Debugger . . . . . . . . . . 95 7.3.1 Step . . . . . . . . . . . . . . 96 7.3.2 Trace . . . . . . . . . . . . . . 97 7.3.3 Watch . . . . . . . . . . . . . . 97 7.3.4 Expression Evaluate . . . . . . . 98 7.3.5 Animation . . . . . . . . . . . . 98 7.3.6 To Here . . . . . . . . . . . . . 99 7.4 Miscellaneous keystrokes . . . . . . . 99 7.5 Command Line Parameters . . . . . . . 100 iv Tables Table 2.1: Valid and Invalid Variable Names . .10 Table 2.2: Numeric and String Constants . . . .11 Table 2.3: Array Subscription . . . . . . . . .12 Table 2.4: RExL Math Operators . . . . . . . . .13 Table 2.5: Logical Operators . . . . . . . . . .14 Table 2.6: Comparison Operators . . . . . . . .14 Table 2.7: Function Families . . . . . . . . . .15 Table 2.8: Some Expressions . . . . . . . . . .16 Table 2.9: Operator Precedence . . . . . . . . .17 Table 2.10: Examples of Operator Precedence . .18 Table 2.11: Examples of Assignments . . . . . .19 Table 2.12: Rule Modifiers . . . . . . . . . . .23 Table 2.13: Other Modifiers . . . . . . . . . .25 Table 2.14: Expression Truth Values . . . . . .25 Table 4.1: ASCII Color Translation Table . . . .48 Table 4.2: Function Parameter Abbreviations . .55 Table 5.1: Screen Types . . . . . . . . . . . .64 Table 5.2: Valid Combinations of Screen and Field Type . . . . . . . . . . . . . . . .64 Table 6.1: Screen Designer Cursor Keys . . . . .71 Table 6.2: Valid Field Sizes . . . . . . . . . .72 Table 6.3: Valid Field Attributes . . . . . . .81 Table 6.4: Keys in Line Draw Mode . . . . . . .86 v - Main Manual. Page: 3 - Chapter 1 Introduction This chapter provides a brief introduction to RExL, its system requirements, installation and capabilities and quick signpost to the rest of the manual. 1.1 What is RExL RExL, short for Rule-base EXpert Language is a fourth generation language product for PC compatible computers which is based upon the `expert system' programming paradigm. It allows the applications developer to prototype applications rapidly and easily, while producing code which is easy to follow and understand. RExL comprises an editor for creating and modifying applications and a runtime module with incorporated debugger for testing and running the resulting application. RExL was developed with the following goals in mind: o Ease of use: Menus and pop-up lists are available times through hotkeys for experienced users, and via pulldown menus for those not so familiar with RExL. Online context-sensitive, cross referenced help is available at all times to the user. o Integrity: RExL was conceived as a single unit, with all features intimately connected together, unlike traditional languages where editors and debuggers are general purpose tools and not tailored for specific languages. o Power: RExL not only has a powerful internal language with 178 functions available but also has a fully integrated screen designer and dBase compatible database module. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 4 - 1.2 System requirements RExL will run on the IBM PS/2, PC/AT, PC/XT, PC, PC/Jr, and on IBM PC clones. The minimum requirements are: o 256 KB of memory, although RExL can use as much conventional DOS memory as is available. o PC-DOS 3.0 or greater or MS-DOS 3.0 or greater. o One high density 5.25" or one 720k 3.5" diskette drive, although a hard drive with at least 600k free is recommended. o An 80-column video card and monitor. o REXL.EXE, the editor and REXLRD.EXE, the runtime- debugger module. 1.3 Installation If you are installing the Shareware version, installation of RExL is accomplished easily. Copy the archive files REXLA211.ZIP and REXLB211.ZIP into a directory on your hard disk (we suggest "\REXL") and unzip the archive, using the commands: pkunzip -d rexla211 pkunzip -d rexlb211 The installation will proceed automatically and will require about 1.5Mb of disk space. If you are installing the full registered version, insert the first distribution disk in your disk drive, log onto it, issue the DOS command install and follow the prompts. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 5 - 1.4 Features The RExL package comes in three main parts: o The editor which is used for creating and modifying applications written in RExL, o The runtime-debugger module which is used to run and debug applications. o The supplementary utilities, stored in the second archive in the shareware version, which complete the suite of development tools. The next two sections provide a brief overview of both these modules. The final section in this chapter gives a quick introduction to RExL's internal language. 1.4.1 Editor RExL's editor uses the concept of `folding text' to make the programmer's job easier. In any computer language, applications are built up in a pyramidal manner, using procedures within procedures: this gives the program a two dimensional structure which has been ignored by traditional flat file editors. RExL on the other hand understands this structure and allows the programmer to access procedures immediately, without having to do searches or large cursor movements. Lists of all entities defined in your application are available at all times within the editor, and most entity lists have cross reference facilities. The screen designer is an integral part of the editor and features the following: o Block mark, copy, move, delete, color, fill and alignment, o Box and line drawing, o Subscreen manipulation, o IO fields : numeric input and output, character input and output, radio buttons, check boxes, toggle lists and menus, o Screen compression within single screen files. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 6 - The cross referenced help system is available at all times while within the editor and contains almost six thousand lines of context sensitive help. All RExL functions are fully explained in the help and come complete with examples of their use. 1.4.2 Runtime-Debugger RExL's debugger and runtime module feature line step, trace and instruction animation using industry standard keystrokes. A full watch facility and comprehensive expression evaluator can be used to check variables and expressions during execution of an application. As with the editor, all features are available via debugger hotkeys and pull down menus. As in the editor, on-the-fly macro definition, store and retrieval is also featured. 1.4.3 Language RExL's internal language has been designed to resemble BASIC. It supplies all the normal mathematical operators of division, multiplication, addition, subtraction, negation, exponentiation and logical OR, AND and NOT. The language has one hundred and seventy-eight functions which are grouped under the following headings: o Database: The integral database is dBase III compatible and supports the use of standard index files. There are forty functions controlling the database module. The number of data files and index files open concurrently is limited only by DOS. o Date-Time: There is a full set of date and time handling functions. These can use the three most common date and time formats of the USA, Europe and Japan. There are nineteen functions in this category. o DOS: The fourteen DOS interface functions perform the most commonly required procedures, such as file copy, rename, delete, directory maintenance and system identification. o Math: There are forty mathematical and financial functions (not including the math functions which operate on arrays and databases). The math functions cover all the standard trigonometric functions, as - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 7 - well as random number generation, boolean algebra and ASCII character manipulation. The financial functions cover the areas of loans and annuities. o Array handling: There are nine functions which operate on RExL arrays. Arrays may be numeric or string in type and can have up to three dimensions. o Miscellaneous: There are sixty-two miscellaneous functions which control character string manipulation, error handling, simple numeric and string screen IO and keyboard handling, binary and logical operations and arithmetic. The language itself is based upon the concept of rules, which are equivalent to procedures in more conventional programming languages. Rules are made up of logical blocks of lines, known as AND-blocks, which execute in much the same manner as Prolog predicates. The lines themselves within the rule can be built up of executable statements, in RExL's internal language, or be made up of other rules. Screens generated using the screen designer are accessed in much the same manner as rules. The screen designer allows numeric and character IO, dialog screen generation, online help and printer access. 1.5 The Manual Where keystrokes are specified, the shift, alt or ctrl segment is written first with the combination key second. For example, to call up language help, the keystroke is as follows: Press down the <Ctrl> key and while it is down, press the <F1> key. This keystroke is written as <Ctrl-F1>. The plan of the manual is : o General introduction to RExL o General guide to RExL's language o Quick start guide o In-depth guide to the editor o In-depth guide to the screen designer (two chapters) - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 8 - o In-depth guide to the debugger o Appendices - Guide to Function Families - Database Programming - Function reference - Keystroke reference - Afterword It is recommended that at the very least, you should read the language guide and the quick start guide. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 9 - Chapter 2 Language RExL's language was designed to resemble BASIC, so that users who had experience in this language would have little difficulty in switching to RExL. This chapter will introduce all of the basic concepts which you'll need to understand before you can begin to program in RExL. If you have programmed before, then a quick read through this chapter should be adequate, since the concepts presented are common across most programming languages. 2.1 Variables A variable is a name which is used to refer to a location in memory which stores a retrievable value. In RExL, there are two types of variable: o Numeric variables which contain numeric information. These variables can range in absolute value from 2.225074x10^-308 to 9.7693x10^308 and can hold numbers accurate to about fifteen decimal digits of precision. o String variables which contain character information. These have a maximum length of eighty characters. RExL variable names follow the standard conventions for variable names in most languages. These are that they must consist of a letter followed by an unbroken sequence of letters, digits or the underscore character, _. Note that for compatibility with future RExL products, an underscore is not allowed as the initial letter of a variable name. To distinguish between string and numeric variables, all string variable names have a dollar sign, $, as the last letter in their name. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 10 - The following list gives some typical variable names: Table 2.1: Valid and Invalid Variable Names name$ String variable my_age Numeric variable 1st Invalid : initial character is not a letter my age Invalid : space included in the middle of the name co$t Invalid : characters after the dollar sign addr$$ Invalid : double dollar at end 2.2 Constants A constant is an invariable numeric or string value. Numeric constants are simply numbers such as 0, 10, 123.456 and so on. They have the same range of value as the numeric variables above. For large numbers above one million trillion, RExL uses the standard computer format scientific notation. This format is almost identical to that of scientific notation and consists of a mantissa which can be up to fifteen digits long and contains the significant digits of the number, expressed as a number between one and ten. The mantissa is followed by the letter E (or e, standing for exponent) followed by a plus or minus symbol followed by a number between 15 and 308, representing the power of ten with which the mantissa is to be multiplied. There are no spaces in between the different sections of the number and a plus sign is assumed if the plus or minus symbol is omitted. Thus the average distance from the sun to the earth can be expressed in this format as 5.8925E+12 = 5.8925x10^12 inches. String (or character) constants are simply lists of characters. They are delimited at either end by the double quotation mark ", and may contain any ASCII character except that of zero, used internally. The following table lists a few typical string and numeric constants. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 11 - Table 2.2: Numeric and String Constants 1e+6 Numeric value of one million 5e-3 Numeric value of five thousandths 1e+-376 Illegal: confusion over plus/minus and the exponent is greater than 308 "Hello" The string `Hello' "Whoops Illegal: no closing double quotation mark 2.3 Arrays Some applications require lists of string or numeric information. For example, the list of monthly sales figures for a single year would require a list of twelve numeric variables, one for each month. RExL supports the use of arrays of string and numeric variables to store this type of information. An individual number or string item in an array is known as an element of that array. Arrays more complex than simple lists are also possible, in fact arrays may have up to three dimensions specified. For example, if the sales figures for a single year for a number of different departments were stored, although they could be stored as above in a one dimensional list, it is more convenient to store them as a two dimensional list or array: one dimension to locate the month and one dimension to locate the department number. Similarly three dimensional arrays could be used to store the monthly sales figures for different departments across different years. Two dimensional arrays can be thought of as a (numeric or string type) grid with the dimensions specified relating to the rows and columns of the grid. Three dimensional arrays can be thought of as a stack of these grids. It is clearly immaterial to RExL whether the any particular dimension refers to the row number, column number or depth of a particular element, however, to keep things clear in your mind, you should adopt a standard method of reference. We suggest the convention that the first dimension is column number, the second is the row number and the third dimension is the depth. This convention is used elsewhere in RExL and conforms to the standard (x,y,z) notation used in Cartesian geometry. To reference a particular element in an array, RExL needs to know its position within the array. This is specified by placing the `co-ordinates' of the element of interest in - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 12 - square brackets immediately after the array's name. The co-ordinates of a particular element are known as the array element subscripts and are based at zero, meaning that the first element of an array is indexed by a subscript of zero, the second by a value of one and so on.(This behaviour is compatible with the C language and is adhered to throughout RExL where all co-ordinates, string indexes and so on are zero based.) In two and three dimensional arrays, the separate subscripts are separated by commas. Note that an array must by subscripted by the correct number of subscripts. The following table give a few examples of addressing individual elements of arrays. Table 2.3: Array Subscription name$[0] Returns first element in name$[] age[6] Returns seventh element in age[] sales[3,0] Returns the number in the first row of the fourth column of the two dimensional array sales[] By default, all arrays are dimensioned to ten elements. This can be changed through the variable dictionary, described in the chapter on the editor. When you are using three dimensional arrays, be aware that large amounts of memory are consumed. As a guide to determining the exact amount used, each element of a numeric array of any dimension uses eight bytes of storage. For string arrays, each element uses four bytes (when the application starts) and a further eighty-one bytes when an element is first accessed. This behaviour for string arrays helps to conserve memory if not all elements in an array are used, as is usually the case. 2.4 Operators 2.4.1 Mathematical Operators An operator is a symbol which performs some action upon an operand (or operands) and returns a value. The standard mathematical symbols + - x and / with which most people are familiar are supported in RExL, along with number of extra ones. They are listed in the following table: - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 13 - Table 2.4: RExL Math Operators * Multiplication ^ Exponentiation / Division & Logical AND + Addition | Logical OR - Subtraction ! Logical NOT Note that the minus sign can also be used to denote a unary minus, that is one which changes the sign of its immediate operand. The four operators in the right hand column may not be familiar to you. The first operator, the exponentiation operator a caret, ^, is used to raise the first operand to the power of the second. Thus, 2^2=4 and 3^2=9. The logical AND operator, the ampersand symbol &, returns the result of a logical AND of the both operands. This is equal to one if both operands are non zero, otherwise the result is zero. So, 1&1 gives 1 but 1&0 returns 0. The logical OR operator, the piping symbol |, returns the result of a logical OR of both operands. This is equal to one if either of the two operands are non zero, otherwise it is zero. So, 0|1 gives 1 but 0|0 gives 0. The final logical operator symbol, the exclamation mark !, performs a logical inversion of its single operand. This means that it will reverse the logical meaning of the value to which it is applied. Thus !1 returns 0 and !0 returns 1. When dealing with the logical operators &, | and !, it may help you to think of a value of zero meaning False and a non-zero value meaning True. Thus, !1 is equivalent to !True, giving False and 1&0 is equivalent to True & False giving False. The following table lists the results of the logical operations of Not, Or and And applied to a pair of True and False operands. These logical operators are sometimes referred to as boolean operators, after the Irish mathematician, George Boole, who developed the algebra of logic. A number of more complex logical operations are available as function calls, including exclusive-or, implication and equivalence. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 14 - Table 2.5: Logical Operators A B !A A&B A|B 0 0 1 0 0 0 1 1 0 1 1 0 0 0 1 1 1 0 1 1 2.4.2 Comparison Operators The final set of RExL symbols are the comparison operators, which are used to compare one string or number value with another value of the same type. There are six comparison operators which are listed below: Table 2.6: Comparison Operators = Test for equality > Test for greater than <> Test for inequality <= Test for less than or equal to < Test for less than >= Test for greater than or equal to These operators are defined for both string and numeric types. When applied to string type operands, RExL uses the ASCII character set to determine if one string is `less than' or `greater than' another. Refer to appendix F for an table of ASCII characters. 2.5 Functions A function is an in-built part of RExL's internal language which performs some action, or calculation on some values, and then returns a value of some specific type. Like variables, the type of the value they return is indicated by the presence or absence of a dollar sign. In general, the return type of a function is not related to its parameters, the value or values which the function operates upon. The process of using a function is generally referred to as calling that function. The values which are given (or passed) to the function are known as parameters. You are probably familiar with some functions already: the mathematical functions log, tan, cos and so forth, are functions (and available in RExL), since they are passed - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 15 - some value and return the value of the function at that particular point. Thus, the value of the tan function at pi radians evaluates as zero. This could be coded in RExL as tan(3.1416). Every RExL function uses a fixed number of parameters, generally of fixed type. For example, the math functions above require the use of numeric parameters since trying to find the logarithm of a string is meaningless. The DISPLAY() function will write a string on the screen to the current cursor location. This function takes only one parameter, a string. To write the string "Hello, world" on the screen, we could write a RExL line such as DISPLAY("Hello, world"). Passing arrays to functions is rather more complex: Because some functions taking arrays require arrays of a specific dimension, dummy subscripts must be passed in place of numeric ones (the dummy subscript used is the hash symbol, #). The dummy subscripts are mainly for the benefit of the internal syntax checker which checks to make sure that you are not passing a one dimensional array to a function which requires a two dimensional array. For example, to call the function ARavg(), which averages the values of a one dimensional array and requires the name of an array and two numbers, the function call could be written as ARavg(numarr[#],0,9). RExL's function list is divided into six `families' of functions, each of which is used for some different aspect. To make the functions easier to locate and remember, every function in a particular family (except for the miscellaneous functions family!) start with the same two letters, both of which are capitalised. The following table lists the function families: Table 2.7: Function Families Letter Abbreviation Uses of Family AR Array handling BT Binary bit operations DB Database handling DT Date operations ER Error handling KB Keyboard handling OS Operating system functions - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 16 - In the current release of RExL, there are one hundred and seventy-eight functions available. The miscellaneous functions have no special initial letters. 2.6 Expressions An expression combines constants, variables and function call return values using RExL's mathematical operators to produce a single result. For example, the expression 2+2 produces the result 4. As a general rule, the type (string or numeric) of the result of an expression is the same as that of the elements of the expression, although there is one exception to this rule. This is as follows: when strings are compared, or more properly, operated upon by the comparison operators, the return result is a numeric value. This at first may seem strange, but it makes sense when you apply the earlier suggestion that non-zero values can be thought of as being `true' and zero values being False . Thus, if two strings are compared for equality, we would expect a `true' to be returned if they were equal and a `False ' otherwise. The same convention holds true for comparison of numeric values. In RExL, a true expression is assigned the value of one and a False expression is assigned a value of zero. When using numeric expressions, all the operators previously defined are valid. When using strings however, the only valid mathematical operator is the + sign, used for string concatenation or addition. It should be obvious that attempting to subtract, multiply, divide, take powers or perform logical operations upon strings has no meaning. Examine the following expressions and satisfy yourself that they do what they say they do: Table 2.8: Some Expressions a*10 Returns the result of the multiplication of the numeric variable a and the number 10 time[0]*speed[0] Returns the result of the multiplication of the first element of the array time[] and the first element of the array speed[] a$+"end" Returns the value of a$ with the string constant "end" appended to it. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 17 - There is, however, a problem in evaluating expressions when there is more than one operator: This is to determine the order in which the sub-expressions (within the expression as a whole) are to be evaluated. For example is the expression 1+2*3 to be evaluated as 1+(2*3) or (1+2)*3? To overcome this problem, every operator has a precedence, so that sub- expressions having operators of higher precedence are evaluated before those of low precedence. When two operators have the same precedence, the expression will be evaluated from left to right, as you would expect. The complete list of operator precedence is given at the end of this section. There is one final operator, the assignment operator which is denoted by the symbol of colon followed by an equals sign :=. It is used for assigning a variable to some value. This will be covered in the next section and is introduced here so that it can be included in the table of operator precedence. Table 2.9: Operator Precedence Precedence Operator Meaning 8 () Bracketing of sub-expressions 7 ! ^ Logical NOT and exponentiation 6 * / Multiply and divide 5 + - Add and subtract 4 < > <> = <= >= String and numeric comparison 3 & Logical AND 2 | Logical OR 1 := Assignment From the table above it can be deduced that for the example given earlier, the expression would be evaluated as 1+(2*3) rather than the simple left-to-right parsing of (1+2)*3. The following table gives some examples of expressions without brackets and the equivalent bracketed expressions to demonstrate how the operator precedence table is used to determine the exact order of evaluation. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 18 - Table 2.10: Examples of Operator Precedence Expression Evaluated as Result 1+2*3 1+(2*3) 7 1*2+3 (1*2)+3 5 1+2*3^4 1+(2*(3^4)) 163 2*TAN(3.1416/4) 2*TAN(0.786) 2 2*(10=20) 2*(0) 0 2*10=20 (2*10)=20 1 "a"="b" 0 "a"<"b" 1 Don't proceed until you understand all of the results above, since the basic ideas presented there are present throughout RExL. Note particularly, the final two expressions which are not intuitively obvious since they depend on the comparison operators, and thus return numeric results. The second of the two examples involving string constants requires knowledge of the ASCII character set. For more information on this, consult the ASCII table given in appendix F. 2.7 Assignments An assignment is a special case of an expression. It assigns the value of some expression to a variable, which can be either be simple or array type, using the assignment operator :=. The return type of an expression must be the same type as the variable whose value is being assigned. Thus it is not possible to assign a string to a numeric variable or vice versa. The general format of an assignment is as follows: <variable> := <expression> The <variable> above is sometimes referred to as an LValue, short for Left hand Value. When using non-array variables, the LValue is simply the name of the variable. However, when using array type variables, you must tell RExL what element you are trying to assign a value to. Thus, you must include the relevant array element subscripts in brackets after the array variable's name. The following table gives some examples of variable assignment statements: - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 19 - Table 2.11: Examples of Assignments Expression Result of operation a:=5 a is assigned the value of 5 t$:="test" t$ is assigned the string "test" a:=a+1 a is assigned the value of a plus 1, ie: 6 t$:=t$+" string" " string" is appended to the old value of t$ to give a new t$ value of "test string" ar[0]:=10 The first element of the numeric array ar[] is assigned a value of 10 ar[a]:=a+4 The seventh element of ar[] is assigned 10 str$[1]:=t$ The second element of str$[] is assigned the string "test string" Note particularly, the third and fourth statements which seem rather counter-intuitive. Recall from the table of operator precedence that the assignment operator has the lowest precedence, and thus will be evaluated after everything else. Thus, the meaning of the statement becomes `add one to the variable a and assign the result of this addition to the variable a.' An assignment will always returns a `true' value of one. 2.8 Statements `Statement' is a generic term for a complete expression or assignment in RExL. In other words, it forms a complete RExL `sentence' which can be interpreted and executed. When an application is created, it consists of a list of executable statements, each of which returns some value (since they are expressions). RExL uses this return value from a statement to determine its next action: Whether to execute the next statement in the current list or to jump to some other location in the application. This will be more fully explained in the section on rules. 2.9 Inference Inference is the process of drawing a conclusion from a set of propositions, each of which can be either true or False . RExL operates using an inference engine: This is used to execute the application and to draw conclusions from its - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 20 - individual lines, each of which will evaluate as either true or False and are therefore equivalent to propositions. 2.10 Rules and Execution A rule is the fundamental building block of all RExL applications and is roughly equivalent to a procedure in conventional programming languages. Rules are made up of blocks of lines which may be executable statements, or further rules. Every non-blank line in a RExL application has a leading connector. This is a logical `preposition' which tells the inference engine how to link up this line with the previous and following lines in its rule. In the current release, there are three connectors: AND, If and OR. The use is an application of these connectors is best illustrated by a simple example. If The temperature is ok And It is not raining And Tell user to go for a walk Or Tell user to stay inside and play a game of chess The meaning of this should be fairly clear: The computer will tell the user to go for a walk if the temperature is ok and it is not raining, or else, the computer will tell the user to play chess. What actually happens during execution is this: the inference engine starts on the first line and asks the user `Is the temperature ok ?' (for the moment, don't worry about how the computer asks this question or how it gets the reply). If the answer to this question is yes, that is True, then the inference engine will let execution pass to the next line and ask the question `Is it raining?' If the answer is again true, then the computer will `draw the conclusion' (or more properly, execute the line) that the user should go for a walk. If on the other hand, the user had replied no, or False, to either of the questions then the inference engine would have determined that the conditions for a walk were not present, passed execution to the or clause and therefore suggested that the user play chess instead. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 21 - Whether the user is advised to stay inside or to go out, the result of the rule as a whole is the same: It succeeds, since it has successfully drawn a conclusion. RExL inserts the connectors itself. The rules for connectors can be generalised as follows: The first line in an unbroken sequence of lines will have the connector OR, unless it is the first non-blank line in a rule, which will always have the connector If (the meaning of If and OR is functionally identical). All other lines in the rule will have the connector AND. It is for this reason that the blocks of lines are sometimes referred to as And-Blocks. The rules which the inference engine follows for execution are as follows: In any rule, execution will begin at the first non-blank line of the first AND-block within the rule, that is the line with the If as its connector. It continues sequentially through the block until one of two conditions occur: Either a line returns the value zero (for False), in which case execution will jump and continue at the start of the next AND block in the rule. Or else execution successfully reaches the end of an AND block, in which case the rule returns the value True without any further statement execution within that rule. If, on the other hand, a line returns False, and execution tries to continue at the beginning of the next AND block when there is none present, then the rule will return False. 2.11 Subrules If we decided to make the application objective in assessing the temperature, rather than relying on the user to do so, we could as the user whether the temperature is within a certain range to find out whether it is really `ok' or not. We would therefore expand the definition of the The temperature is ok rule. Instead of being a simple unexpanded line, this rule would then `contain' subrules such as the following: If The temperature is more than 10 degrees And The temperature is less than 40 degrees Therefore, when the application is started, instead of RExL simply asking the question `Is the temperature ok?', it would instead ask the two more specific questions to - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 22 - determine if the temperature is between ten and forty degrees (Celsius!). During execution what actually happens is that RExL checks to see if the rule being executed can be expanded. If so, then execution passes to the expanded portion, but remembers where the rule was `called' from. It then executes the lines within the expanded rule and eventually returns a True or False value to the original caller of the rule. So, going back to the example, when execution reaches the rule `Is the temperature ok?', it expands the definition and asks `Is the temperature more than 10 degrees ?' If the answer is `yes' or True, then the next question is asked, `Is the temperature less than 40 degrees?' If the answer is again True, then both conditions in the expanded rule are True and so the the rule would succeed, return True and RExL will then ask whether it is raining or not, continuing from where it left off in the parent rule. If, on the other hand, the user replies `no' or False, to either of the questions about temperature, then the expanded rule fails and returns False to the parent rule, thus making the conditions for a walk unavailable, and therefore suggesting that the user play chess. Every application has a master rule (sometimes known as a `main rule') which is called by RExL when the application starts. In the current release of RExL, this rule is called Main Program and cannot be changed. All other rules can therefore be considered as subrules of the main rule. It is very important that you understand thoroughly the action of the inference engine in RExL, and how it executes rules and returns values. All RExL applications are based upon the ideas presented in this and the previous section. You should reread them if you are not happy with them. 2.12 Rule Modifiers The rules in the previous two sections were basic rules. That is, that they acted as rule calls and were executed every time the application called them. There are, however, a number of different variations upon this theme. These rule modifiers perform some action other than a simple rule call. The six rule modifiers are as follows: - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 23 - Table 2.12: Rule Modifiers Abbreviation Used for BackTo Rule recall Not Return inversion of rule call While Continuously execute rule while true Multi Make rule multi-pass Single Make rule single-pass Zap Reset status of single-pass rule In the editor, the modifiers are placed between the line's connector and the name of the rule. The function of the six modifiers are explained in the next six subsections. 2.12.1 BackTo Whenever a rule is called by an application, RExL stores the place in the listing where the rule was called from in a special area known as the call stack (so called because rule calls are `stacked' there). The BackTo modifier is used to clear the call stack back to the last instance of some previous rule. This can be used when for example, when the user selects a menu option to restart an application, the application could contain a line such as: And BackTo Main Program BackTo may also come in useful when an error occurs and the program needs to restart the execution from some point. Note that if the rule specified doesn't exist in the call stack, then the application will end, since it can't locate any place to restart from. 2.12.2 Not When Not is applied to a rule, it reverses the logical return value of the rule. Thus, if rule call returns True, but the rule is modified by the Not, then the rule will evaluate as False. The Not modifier is mostly used for logical tests which are easier to evaluate as True than False (and vice versa). 2.12.3 While The function of the While modifier is to execute a rule continuously while its return value is True. This could be useful for doing some work in a database, where the rule is designed to fail when the end of the database is reached. A - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 24 - rule call which is prefixed by While will always fail because of the nature of the modifier. 2.12.4 Multi By default, all RExL rules are multi-pass rules. This means that a rule is expanded and evaluated each and every time it is called (although this is not standard for expert systems, where all rules are single-pass). However, it is sometimes useful to have rules which are not reevaluated every time they are called, but save their status from one call to the next. These rules are known as single-pass rules. The Multi modifier is used to make a single-pass rule a multi-pass rule. 2.12.5 Single The Single modifier performs the reverse of what the Multi modifier does: It makes a multi-pass rule (the RExL default) into a single-pass rule. 2.12.6 Zap When a one-pass rule is set up and has been evaluated, but for some reason, needs to be to be reevaluated (because, for example, of some changed condition) then the Zap modifier can be used to reset the status of the one-pass rule to unknown, and thus the rule will be reexecuted when it is next called. 2.13 Other Modifiers Every line, other than a simple rule call, must have a modifier attached to it. We have already some across the list of the six modifiers for rules in the previous section. That list is now completed with the list of modifiers for the other line types: - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 25 - Table 2.13: Other Modifiers Modifier Applicable to [Expr ] Statements [Dialg] Input and output [Dsply] Screens [Help ] Screens [Menu ] Screens [Print] Screens Note that all non-rule modifiers are surrounded in square brackets. This is to help the programmer distinguish at a glance whether the line is a rule or screen/statement. The final five modifiers in the table are applicable only to screens and are dealt with in the chapter on the screen designer. The [Expr] modifier at the beginning of a line indicates that the line is a statement (either an assignment or expression). Expressions, as noted before, can return either a zero value for False or a non-zero value for True, while assignments will always return True. Examine the following list of statements and satisfy yourself that they return the values indicated. Table 2.14: Expression Truth Values Statement Returns 1 True 0 False 123*23 True 10-10 False a:=10 True a=10*("h"="h") True - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 26 - - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 27 - Chapter 3 Quick Start 3.1 Introduction In this chapter, we'll go through the process of creating a small application in RExL. First, we'll use the editor to create it, and then the runtime module to run it. In the final section, we'll use the integrated debugger to debug the application. If you haven't read the chapter on RExL's language, you should do so now, since the application developed there will be created here, and the editor won't make much sense unless you understand the language. Every RExL application is stored on disk in two parts, the first part is the application image. This is the listing which you can edit using the editor. The second part is the screen file which stores the screens used in the application. The application image file has a file extension of ".RXL" while the screen file has one of ".SCR". Changes to the screen file are included immediately, while those to the application listing are saved only when RExL is instructed to do so. It is for this reason that you should not modify any screens in an application without updating the application image on disk, since the two files may go out of synchronisation. The RExL system also comes in two parts. The first part, the editor, is used for creating and maintaining the application and for designing the application's screens. The second part is the runtime-debugger which is used to execute and debug the application. This two part approach is used because it maximises the amount of memory available to each module. The two modules are linked, so that you can run and debug you application without having to exit from the editor and explicitly run the debugger. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 28 - 3.2 Creating an Application Start the editor by typing rexl at the DOS prompt and press <Enter>. After a second or two, the editor screen appears. If any error messages appear, just press a key and ignore them. The menu bar across the top of the screen uses the standard menu keys of <Left Arrow> and <Right Arrow> to move the hilite bar and <Enter> to select an option. The hilited letters in the menu titles (ie `F' in File) can be used to select an option as can a combination of the Alt key and the letter (ie <Alt-O> to select the options menu). We want to edit the application, so select the Edit option from the main menu and press <Enter>. The first line in the central edit window will be hilited in gray, the connector `If' will appear at the left end of the hilite bar and the cursor will be placed a few characters in from this. The first line of our application was `The temperature is ok', so just type this in to the editor and press <Enter>. The cursor and hilite bar will then jump to the next line and an `And' connector will appear at the start, in the same position as the `If' of the previous line. The rules for the automatic insertion of connectors will be explained shortly. Enter in the next line of text, `It is not raining' and again press <Enter> to go to the next line (You can press <Down-Arrow> to proceed if you want to, just be careful not to insert blank lines, since these will change the meaning of the rule as we will soon see). The final line of this And-Block is `Tell the user to go for a walk', so enter this. The first And-Block of our mini-application has now been finished. We now need to enter the final line, telling the user what to do. Place the hilite bar over the `Tell the user to go for a walk' rule and press the <Tab> key. This will expand the rule. Note that the rule name is now displayed on the line underneath the main menu bar. To display the RExL's advice, we'll use the `DISPLAY()' function which we met earlier. We'll need to tell RExL that what we are entering is a statement, so press the <F4> key. This will generate the `[Expr]' line modifier and place it immediately after the `If' line connector. If the modifier were omitted, RExL would assume that the line was a rule and - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 29 - not an expression. With the modifier in place, enter the expression `DISPLAY("You should go out and have a walk")' This completes the first section of our application. Press <Shift-Tab> to return from the sub rule to the parent rule (note that the rule name display area now displays the name `Main Program'). Press <Down-Arrow> (or <Enter>) twice, so that a blank line now exists between the first AND-block and the hilite bar. You'll notice that the connector at the beginning of the line has now become `Or'. The rule which RExL follows for generating connectors is simple. Every line begins with `And', unless one of two conditions is true: The first line of an AND-block will have the connector `Or', unless the line is the first line in the rule, in which case the connector will be `If'. All other non-blank lines will have the connector `And', while blank lines have no connector. Type in the text for the `Or' condition: `Tell the user to stay inside and play a game of chess'. Press <Tab> to expand the rule and then enter the expression `DISPLAY("Stay inside and play a game of chess")', not forgetting to press <F4> to specify the `[Expr]' modifier. 3.3 Running the Application The application is now ready to run. Press <F2> to save it and select the `Run' option from the main menu (by pressing <Alt-R>, or <Esc> to return to the main menu and using the cursor keys to select). Select the first option in that menu, `Run', and press <Enter>. Within a few seconds, the application should begin running. The screen will change to a light gray background with two cyan boxes in the center of the screen. The upper of the two boxes will contain the name of the first rule in the application, `The temperature is ok'. Underneath this, there is a small menu with two options, true and false. When one of these options is selected, its value returned to RExL directly. Recall from the explanation of the application in the previous chapter, that the user would be advised to go for a walk if `the temperature was ok' and `it is not raining'. Therefore, for this conclusion to be drawn, the first reply must be true (select the `True' option from the menu) as well as the second option (`True' again). When both conditions have been satisfied, RExL will display the - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 30 - string `You should go for a walk' on the monitor. Selecting a value of false for either of the conditions will cause RExL to draw the other conclusion, that the user should play a game of chess. When RExL has printed its advice, the application will terminate and you will be returned to the editor. If this happens too quickly to see the result, press <Alt-F5> from within the edit window in the editor to display the user screen, the screen as it existed before the editor was loaded. You should run this application a few times and satisfy yourself that you understand what it is doing. 3.4 Expanding the Application We will now expand the application using custom screens designed using the screen designer. Recall from the language chapter that we wished to make a more objective assessment of whether the temperature was ok by adding two sub rules to that rule. Instead of doing this, we shall instead add an input screen to get the actual temperature from the user and to perform numeric comparisons upon it directly. Expand the definition of the `The temperature is ok' rule and type in the following `Input a value for temperature' and press <F10>. A small menu will appear with six options on it (these are the different screen types available). We want the program to perform some input and output, or dialog, with the user, so select the `Dialog' option and press <Enter>. The editor screen disappears and you will see the start up screen of screen designer which is filled with the quarter tone character `░'. Move somewhere slightly to the left of the center of the screen and type `Enter the temperature :' We now want to define an input field, so that the user can input a value to RExL. Press <Ctrl-I> to start the field definition, press <Tab> once to make the field ten characters wide, and press <Enter> to accept that size. A box will appear asking for an `input expression'. As with assignments, this must be an proper LValue. Type in `Temperature'. This will the name of the variable which we'll use to store the value of the temperature in (note that the variable doesn't end in a dollar sign and is - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 31 - therefore a numeric variable, suitable for storing temperature values). Press <Enter> to accept this input expression. The field will now be replaced by a series of ten question marks which are used to indicate an input field. Press <F2> to save the screen and <Esc> to exit from the screen designer and return to the editor. Note that the line's modifier has now become `[Dialg]' to indicate a dialog screen. Move to the next line and enter the expression `Temperature>10' and on the following line, the expression `Temperature<40', remembering to press <F4> each time. Press <Shift-Tab> to return to the main rule, enter the `Tell user to go for a walk' rule, place the hilite bar over the `DISPLAY()' statement and press <Ctrl-Y> (or <Alt-D>) to delete the line. Type the string `Go for walk screen', press <F10> and select the `Display' option from the screen menu. The `Display' screen type is used to display a screen and then wait for a key to be pressed, it's useful for displaying some information and then pausing until the user has read it. When in the screen designer, press <Alt-M> to begin marking a block. Move to the bottom right hand corner of the screen using the arrow keys (<End> and <PgDn> can also be used to do it in two keystrokes) and press <Enter> to select the block. The block menu will now appear: Select the `Paint' option to color the marked block. Use <Up- Arrow> and <Down-Arrow> to change the foreground (text) color and <PgUp> and <PgDn> to change the background (paper) color. Change it to something that looks nice on your monitor. When you have finished painting the block, press <Enter> to accept. Press <Alt-R> to remark the block, select the `Box' option from the menu and select one of the box types from the new menu which appears. Make sure that the first option on this menu is `overlay' and not overwrite, otherwise the text you typed in earlier will be deleted. You might like to try this a few times to see the different types of box available. Move to the center of the screen, type the string `You should go for a walk' and save the screen using <F2> as before. Using the same procedure again, delete the other occurrence of `DISPLAY()' and replace it with a display screen. When you have done this, run the application again. This time, instead of RExL asking you `Is the temperature ok?', it will ask for a temperature value. Enter some value. If the value was between 10 and 40 then both of the comparison - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 32 - expressions entered after the screen in the temperature rule will be evaluated as true and hence the rule will succeed. RExL will then enquire, using the true/false menu, about the next condition for a walk, whether it is raining or not. As before, if true is selected, RExL will display the `Go for a walk' screen, otherwise it will display the other result. Run this application a few times to make sure that you understand how it works. 3.5 Debugging the Application When you are developing an application in RExL, it is very useful to be able to follow the thread of execution to make sure that the application is doing what is you expect it to. The debugger, which is incorporated into the portion of RExL which runs the applications (known as the runtime module), can be used to do just that. Run your application again, but this time, instead of selecting the `Run' option from the run menu, select the `Debug System' option. After a few seconds, the debugger will appear. The interface is much the same as that of the editor and where the comparison is meaningful, the keystrokes are the same, so you shouldn't have any difficulty using it. The screen layout is slightly different from the editor. The main differences are as follows: o To the immediate left of the connector of every non- blank line, there is a status character. This can assume one of three values, `?', `√' and `X', depending upon what the logical status of the line is. `?' for unknown or unevaluated, `√' for logical true and `X' for logical false. o The line about to be executed by RExL is indicated by an arrow between the line modifier and the line's text. Press <F7>. This will trace the application. Depending on the current line type, tracing has different results: If it is over a rule, then the debugger will enter the rule, as if you had pressed <Tab>, and it will place the debugger on the first non-blank line of that rule. If the line is a screen, - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 33 - then the screen will be activated and control will be returned to the debugger when the screen terminates. If the line is an expression, then the line will be evaluated and control again returned to the debugger afterwards. There are a few more conditions which trace controls, these will be covered in the chapter on the debugger. When you pressed <F7>, the hilite bar entered the rule and was placed over the first line in it (which is the screen). Press <F7> again to execute the screen. Enter some value for the temperature in the prompt box which appears (try 30). When you press <Enter>, the screen terminates and the debugger regains control of execution. We will now place a watch on the variable `temperature'. A watch is an expression which is evaluated (or watched) every time that RExL executes a line of code. The watch can be entered in one of two ways: The easiest is to place the cursor somewhere in the word `temperature' on the debugger's screen and then press <Ctrl-W> (<Ctrl-F7> also works). When there is one present, the debugger will pull a word from underneath the cursor and place it into whatever box you call up, in this case the watch expression box. If the word appears, just press <Enter> to accept it, otherwise, type in the word `temperature' and press <Enter>. The expression will be placed in the `watch window', the box on the lower portion of the screen. Following the expression you entered, there will be a colon followed by the current value of that expression, in this case, the value you typed in in the screen. You can set a watch on any valid string or numeric expression. Press <F7> again to execute the line. If you entered a value of 30 for the temperature above, then this line will be true, and the line status indicator at the left edge of the line will display a `√', if you entered some other value causing the line to fail, then the status will be false as indicated by a `X'. Assuming you entered 30, the debugger places the hilite bar on the final non-blank line in the rule which you can now trace. The hilite bar should now be beyond the last line, to indicate that the rule has been evaluated and that execution is about to return to where the rule was called from. Trace again and see this happen. The status indicator of the first rule in the main program should now be `√' to indicate that it was evaluated as true. We will step the next two lines. Stepping is much the same as tracing, the only difference being that if the line being stepped is a rule, then the debugger will not enter the rule - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 34 - definition, it as it does in trace. Press <F8> to step the application. You'll now be presented with the familiar true/false menu screen. Select false and note that the debugger has filled in an `X' as the logical status of the failed rule and left the status of the last rule in the first AND-block as unspecified, using `?'. The hilite bar will now be placed upon the first line of the alternative, the second `AND'-block, so press <F8> to step it. The debugger will not immediately regain control of the application since the screen type being displayed is a `display' screen and so requires a key press to end it. The hilite bar will now be on the final (empty) line of the application. Press one of the execute keys (<F7>, <F8> or space) to terminate the application and return to the editor. Debug the application a few more times to make sure that you understand how stepping, tracing and watching work. If you want to delete a watch expression, press <F6> to switch to the watch window and then <Del> or <Alt-D> to delete the watch. Press <F6> again to return to the code window. There are three other useful features in the debugger which were not covered above. These are the `Execute To' key, <F4>, the `Evaluate Expression' key, <Ctrl-E>, or <Ctrl-F4> and the `Breakpoint' key, <Ctrl-F8>. When you press <F4> on a non-blank line, the application will run until it reaches that line. This is useful when you are somewhere within an application in the code window and you wish to set a temporary breakpoint. For a full discussion of the features in the debugger, consult the chapter on the debugger. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 35 - Chapter 4 The Editor This chapter covers the functions and capabilities of the editor in depth. Because of its size, the screen designer is documented in a chapter of its own, rather than in this chapter. You should have read the chapter on RExL's language before you use the editor, since the two are linked very closely. 4.1 Introduction RExL's editor uses the concept of `folding text' to make the programmer's job easier. As was explained in the previous chapter on the structure of RExL programs, applications are built up in a pyramidal manner, using rules which call further rules and so on. This gives the application a two dimensional structure which has been generally ignored by traditional `flat file' editors. RExL, on the other hand, understands this hierarchical structure and allows the programmer to access procedures immediately, without having to do searches or large cursor movements. You must understand this folding-text approach before you progress to the more complex aspects of the editor. The editor `understands' RExL's language: Whenever a line of RExL code is entered, RExL will check the line's syntax to determine if the line is syntactically valid. If it is, then the text will be scanned for variables which are then be placed into the variable list. The syntax analyser checks not only for errors such as incorrect parameter lists and invalid mathematical operations, but also for less obvious mistakes such as arrays with incorrect number of dimensions. When a new rule is defined, it is placed into the rule list, which can then be used to locate it rapidly. A similar procedure applies to screens which also have their own list. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 36 - RExL's editor user interface is based loosely on Borland's integrated editor, as present in Turbo Pascal versions 4.0 to 5.5 and Turbo C, versions 1.0 to 2.01. Anyone who has used these editors should have no difficulty using RExL. 4.2 Interface Conventions There are a number of keystrokes and conventions which RExL adheres to throughout the system. These are documented here. o Cursor: The cursor can assume one of two shapes, depending on whether it is in insert or overwrite modes. When in insert mode, the cursor will be the same size as the character block and text entered will be inserted into the current cursor location, pushing the text to the right of the cursor off to the right, possibly losing some at the end of the input area. When in overwrite mode, the cursor will be two pixels high and placed at the bottom of the character box. Text entered will erase any text which was previously present at the cursor position. The <Ins> key is used to toggle between insert and overwrite modes. o Cursor Movement: The <Left> and <Right> arrow keys move one character left and right respectively. <Ctrl-Left> and <Ctrl-Right> move one word left and right. <Home> and <End> move to the beginning and end of the input area, unless in the screen designer, where they move to the left hand edge and the right hand edge of the screen. <PgUp> and <PgDn> move up and down by the size of the current window, unless in the screen designer, where they are used to move to the top and bottom of the screen. <Backspace> will delete the character to the left of the cursor, moving the text to the right (and the cursor) one character to the left. <Del> will delete the character underneath the cursor, moving the text to the right one character to the left. o Input: When RExL requests string input, there is generally a default value which is hilited in yellow text on magenta background within the dialog box. RExL interprets the first keystroke pressed in the dialog box as follows: Pressing one of the cursor movement keys will deselect this default so that it - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 37 - may be edited. A non-extended keystroke (these are the letters A to Z, the digits 0 to 9, punctuation marks and all characters whose ASCII codes are greater than 128) will cause the selected string to disappear and the keystroke entered to appear as the first character of the string. Any other keystroke (<Up>, <Down>, <PgUp>, <PgDn>, the function keys, <Alt-> and <Ctrl-> keystroke combinations and so forth) will terminate the dialog and return you to the place from where it originated. Once the dialog has been deselected, input can continue using the standard editing keys. In the current release of RExL, the string entered cannot be wider than its input area. o Scrap Buffer: The scrap buffer is a small one line buffer which can be used to copy and paste small chunks of text from one input area to another. The contents of the scrap buffer are displayed between the curly brackets {} on the status line at the bottom of the editor screen. If the buffer area would overflow on account of the length of the string placed in it, RExL will display the first six characters of the string followed by an ellipsis (three dots) followed by the last six characters of the text. Text is entered into the scrap using <Shift-Enter> and pasted from the scrap using <Shift-Ins>. The scrap may be used, even when it not displayed, such as when in the screen designer. Note that when you terminate RExL lists by pressing <Enter>, the previously hilited item will be pasted into the scrap. Terminating by pressing any other key will not perform the paste. Note that inserting text from the scrap will overwrite any text to the right of the cursor. o Undo: In all string input areas, you can press <Ctrl-U> to undo any changes to the original string. o Help: On line help is available at all times in RExL. There are two forms of help. The first is context- sensitive, meaning that the help which appears is relevant to whatever you are currently trying to do. This help is activated by pressing the <F1> key. Language help will bring up a help screen related to the language keyword which the cursor is placed over. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 38 - This is activated by pressing <Ctrl-F1>. At any time, the last help screen to be displayed can be re-displayed by pressing <Alt-F1>. o Window Move: Most windows in RExL are movable using the standard arrow keys when <Scroll-Lock> is active. This key is normally located at the top right of your keyboard. Note that no windows may be moved over the status line at the bottom of the screen nor the menu bar at the top of the screen. o Macro Recording: You can record macros `on-the-fly' from anywhere within RExL. A macro is a series of keystrokes which can be `recorded' and `played back'. To switch on the macro recording facility, press <Alt-Equals>. A dialog box will pop up requesting the name of the macro which you are about to start recording. If you don't want to assign it a name, just press <Enter>. RExL will then ask for a keystroke to attach the macro to (press <Esc> to abort the record). While you are recording, an `R' will appear in the top left hand corner of the display, press <Alt-Equals> again to turn the macro record off. You can save the macros to disk using the Options/Save macros menu option. Macros can record and replay up 512 keystrokes. The list of macros defined can be displayed by pressing <Alt-Minus>. To play back a macro, hilite the name with the hilite bar and press <Enter>. While a macro is playing, a `P' will appear in the top left corner of the display. o Helix Searching: When using menus in RExL, there are two methods which can be used to select options quicker than using the cursor keys. - Initial letter: Most fixed size menus in RExL have initial letter searching. In this mode, all you need do is type the initial letter of the menu option and it will be automatically selected. The initial letter is usually hilited in light blue. - Helix searching When the number of items in a list or menu is variable, for example as in the rule list, the hilite bar can be brought to an option incrementally by typing the name - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 39 - of the item you are searching for. The portion of the item entered is hilited in a slightly differrent color from the normal hilite bar. The hilite bar will move to the next item which matches the letters entered already, with those letters being colored black on a light gray background. Press <Backspace> to delete letters from the helix search list. For example, if you had a menu with three items in it, One, Two and Three, when the letter T is pressed, the hilite bar moves to the second option, and the first character in the menu bar becomes black on gray. When h is then pressed, the menu bar moves to the next option and hilites the letters Th. o File Name Input: Whenever RExL requests a file name, such as when selecting a file to load into the editor, you may either enter a proper file name, otherwise you can enter a file specification including any of the wild-card characters, ? or *. When using the wild-cards, RExL will give you a menu listing those files which match the file specification entered. Any directories in the current search directory are also displayed in the list and you can change to any one by selecting it from the list. The list of files matching the file specification will be regenerated from the new current directory. For all directories other than the root (when performing wild card file selections) the first option on the menu will be "..\". Selecting this directory will being you to the directory directly above the current one. You can terminate the menu file name select by pressing <Enter> to select a file name, or <Esc> to abort the selection. 4.3 Editor Basics The editor is started by typing `rexl' at the DOS prompt. You can optionally supply a filename for RExL to load immediately into the editor. Ther is one command line option which may be passed to the editor, the `-l' option. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 40 - This is used to tell the editor that it is running on an LCD display. Once the `-l' option has been specified, it will be saved to the configuration file, so it need not be specified again. The editor does two things before it becomes ready for input. Firstly, it attempts to load the RExL configuration file, REXL.CFG. If there is no configuration file present, RExL proceeds without comment. Secondly, if the configuration is so set up, the editor will load the index for the help file, if it is unable to do so, an error will be displayed. The configuration file stores information about the position and colors of the windows in \rexl, the beeping, help, function case, window explosion, bracket matching, list size, LCD and DOS screen storage status flags. When searching for the help file, RExL will first search the current directory and then the directory specified by the REXL environment variable. The editor uses only one command line parameter, -l. This is used to tell RExL that an LCD monochrome screen is attached to the computer which it is running on and to set the screen colors accordingly. Note that the editor can autodetect a standard monochrome screen, but not an LCD monochrome since the hardware does not permit it. Once the -l option has been specified once, RExL will store it in its configuration file along with the rest of the colors and various other configuration data. Once the above procedure has been completed, you will be presented with the main editor screen (note that you can't have all the menus pulled down at once, as they are in this figure! The dots indicate where the menu is normally displayed): [Figure omitted in disk manual] The bar at the top of the screen has five pull down menus. These can be activated by pressing the left and right arrow keys to move from one to the next, and pressing the enter key to select the hilited menu. Once selected, the menu will drop down and a standard selection menu appears. To the right of the six menu titles, is the name of the RExL file which is currently being edited. If the editor has been started with no application name given on the command line, then this file name will be NONAME.RXL. Note that if a file of this name exists in the current directory exists already, then it will be loaded. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 41 - The bottom line of the screen is the status line, and it is here that RExL posts the status of the editor as well as any error messages which are generated. On the left hand end of the status line, between the braces {} is the scrap buffer display, as explained earlier in this chapter. The `Memory :' display on the status line shows the amount of available memory in the editor. If this becomes lower than about 20000 bytes, you may run into lack-of-memory problems. The `Level :' field displays the current rule `depth' which the editor has reached. We will cover rule depth in detail further ahead in this chapter. This has a maximum of 100 levels which is more than enough for most applications. The six menus on the main horizontal menu bar have contents as follows: 4.3.1 File menu ┌───────────────┐ │ Load │ │ New file │ │ Save │ │ Write to │ │ Remove │ │ Change dir │ │ Default drive │ │ OS shell │ │ Quit │ └───────────────┘ The file menu has the following nine options: 1. Load: This option controls the loading of applications into RExL. When this is selected, a file name dialog box (as explained above) appears. This will have as an initial value, the string "*.RXL". 2. New file: This option is used to clear the contents of the editor, as if the editor had been restarted from the DOS prompt. `NONAME.RXL' will be loaded if is present in the current directory. 3. Save: When this option is selected, the application currently in memory will be saved under the name displayed on the top line of the screen. As a short - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 42 - cut keystroke, you can press <F2> from within the main editor window. 4. Write to: This option allows the name of the current application to be changed. When it is chosen, a dialog box will appear requesting a name for the current application to be written to. If a valid name is entered, the application in memory will be saved to disk under the new name and the screen file will be copied. If there is not enough disk space on the current disk drive for the new files, then the operation will fail. The next menu option may be used to remove unwanted files from disk. 5. Remove: This choice allows you to delete a file from disk. You may need to do this is you want to save a file on disk, but are unable to do so through a lack of disk space. 6. Change Dir: This option will allow you to change the active directory. The format used here is much the same as that used in the file name input routine, the only differences being that no file names are displayed in the list and that the current active path (drive name with full directory) will be displayed on the status line at the bottom of the screen. 7. Default Drive: When this option is chosen, a menu will pop up displaying the list of available DOS disk drives. As with the directory selection above, the current active path is displayed on the status display line at the bottom of the screen. 8. OS Shell: If you want to run a DOS command, but do not wish to exit from the editor permanently, choose this option to go into a DOS shell. While you are in the shell, you should not, under any circumstances, run any T&SR programs (such as Sidekick, ScrGrab and so forth), since these programs change critical area of the computer's memory which may cause it to crash unpredictably when you return to RExL. When you are finished in the shell, type `exit' at the DOS prompt to return to RExL. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 43 - 9. Quit: This option terminates RExL and returns you to DOS. If the application currently in memory has been altered, then RExL will prompt you to see if it should be saved. Selecting either of the options will perform the action and then return you to DOS, pressing any other key will return you to the menu. 4.3.2 Edit menu ┌────────────────────────────────┐ │ Edit │ │ Default screen: <None> │ └────────────────────────────────┘ The edit menu contains two options. Selecting the first option, `Edit' will bring you directly into the edit window to begin creation or editing of your application. The edit window will be covered in detail further ahead in this chapter. The second option, `Default screen:' is used for setting the name of the screen which is to be preloaded into the screen designer. When this option is selected, the screen list will be generated and a screen may be chosen to be made the default. If a valid choice is made, then the screen designer will be started so that the default screen itself may be edited. Default screens are most useful when all screens in an application must have the same set of colors, have a few fixed fields or whatever. To clear name of the default screen from the listing, the first option in the screen list, `Clear default screen', should be selected. 4.3.3 Run menu ┌───────────────────┐ │ Run │ │ Debug application │ └───────────────────┘ The run menu has the following two options: 1. Run: When this option is selected, you will be requested to save the application which is currently in memory (if necessary) and the runtime module will be called to run it. Unlike the function of the next option in this menu, the debugger will not be enabled - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 44 - when the application starts. Note that you can enter the full screen debugger at any time during the running of an application by pressing the <Alt-D> keystroke (stands for Debug). When attempting to locate the runtime module, the editor first searches the current directory, then the directory specified by the RExL environment variable, and finally, the entire DOS path, if one exists. If the editor is unable to locate the runtime module, an error to this effect will be generated and the editor will continue running. 2. Debug application: As with the previous menu option, the application in memory will be saved and the runtime module called if possible. The only difference from the previous menu is that the debugger will be started in full screen debug mode, as if <Alt-D> had been pressed upon initiation of the application within the runtime. 4.3.4 Lists menu ┌────────────────────┐ │ Rule list │ │ Screen list │ │ Unused rule list │ │ Unused screen list │ │ Variable list │ │ Function list │ └────────────────────┘ This menu gives you access to all the lists of entities which are defined the current application. Most of the lists have special `hot-links' to other, more specific, lists. These are mentioned briefly at the end of this subsection and covered in more detail further on. All of these lists are also available via hot-keys from within the main editor window. Consult the section on editor keys for more information on this. The lists run menu has the following six options: 1. Rule list: This list contains the names of all of the rules which are currently defined in your application. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 45 - 2. Screen list: This list contains the names of all screens defined in the currently active screen file. 3. Unused rule list: This list shows all rules which, although defined in the normal way, are not actually referenced by the application. Pressing <Alt-D> within this list will delete the unused rule from the application.1 4. Unused screen list: This list gives all screens which are not referenced in the current application. As with the unused rule list above, press <Alt-D> to delete the unused screen from the list and free up the space it occupies within the screen file. 5. Variable list: This list contains all variables. The status line at the bottom of the screen displays the type of the variable, whether numeric or string, and whether it's an array or a simple variable. 6. Function list: This list contains all the functions available in RExL. Press <Ctrl-F1> for help on the hilited function. 7. Graphic rule display: This displays the rule call tree for the current rule. This is covered in more detail in its own section. All the list windows are movable by pressing <Scroll-Lock>, using the arrow keys to position and pressing <Enter>, <Scroll-Lock> or <Esc> to terminate the window move. Note that all lists in RExL feature helix searching. You can also output the contents of any list to a file (or the printer) by pressing <Ctrl-P>, as in DOS. If you terminate any of the lists by pressing <Enter>, then the choice which you selected from that menu will be placed into the scrap buffer, ready for pasting using the <Shift- Insert> keystroke. ____________________________________________________________ 1. Note that deeply recursive rules (those which do not have a reference to themselves in the immediate rule definition) which are not used by other rules are not currently detected as being unused. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 46 - 4.3.5 Options menu ┌───────────────────────┐ │ Load macros │ │ Save macros │ │ Beep off │ │ Function lower case │ │ Exploding windows off │ │ Dictionary size: 500 │ │ Help fast │ │ Bracket match on │ └───────────────────────┘ The options menu controls various system parameters and features not directly connected to the editor per se. 1. Load macros: Any macro definitions you define in the editor may be saved to disk for later retrieval using this menu option. The macro file format is constant across the RExL product range, so that macros defined in the editor may be used in the debugger or in the database manager and so on. Macros are explained in more detail at the beginning of this chapter. 2. Save macros: This option allows you to save macros which can then be reloaded at some future time using the load option above. 3. Beep off: By default, RExL beeps whenever it encounters an error. This beeping can be toggled on and off by selecting this option. 4. Function lower case: By default, all functions in RExL are displayed in their natural case. This is that functions which are members of families are displayed with the first two or three letters capitalised, while the miscellaneous functions are entirely capitalised. This option is used to toggle between upper (or partially upper) case function name display and lower case. 5. Exploding windows off: In its default state, all windows in RExL open instantaneously upon activation. This option can be used to make windows `grow' to full size on the screen. This is only a visual effect and has no effect upon the application. Selecting the option a second time will turn the option off again. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 47 - 6. Dictionary size: The dictionary size is the size of all lists in RExL. This defaults to a list size of 500 items, but can be changed by using this option. Each list entry consumes four bytes of memory. If you are dealing with a particularly large application, you may want to make this list size smaller to conserve memory. 7. Help fast: As explained earlier in this chapter, the editor loads in the help file index when it starts. This is done so that the help can respond instantly to requests. However, the help file index requires about 9000 bytes of memory, so again, if developing large applications, you may wish to disable the automatic loading. The help will then load the index for every request which will slow it down somewhat. 8. Bracket match on: When entering expressions, RExL will automatically hilite matching brackets. This is to help you locate incorrect bracketing in complex expressions. You can toggle this feature by selecting this option. 4.3.6 Import menu ┌─────────────────┐ │ Save to ASCII │ │ Load from ASCII │ │ ASCII Options │ └─────────────────┘ RExL will import and export properly formatted RExL source files in ASCII format. This is mainly done for purposes of documentation and hard copy archival. All attributes of an application are saved, including screen colors, text and screen fields. The ASCII file can become large because of the amount of information contained in it, typically, the size of the listing file is seven to ten times the size of the combined listing and screen files. The foreground and background colors of screens in the application are saved in the ASCII listing file as letters which map directly to colors. The colors are mapped as follows: - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 48 - Table 4.1: ASCII Color Translation Table Letter Color Letter Color 0 Black 1 Dark gray B Blue b Light blue G Green g Light green C Cyan c Light cyan R Red r Light red M Magenta m Light magenta Y Brown y Yellow W Light gray w White The listing file will save the contents of screens correctly, but certain characters, such as the ASCII end- of-file marker, character 26, may confuse other DOS programs which read and write ASCII files, notably Sidekick, WordStar and so on, although RExL will load the file correctly. Furthermore, the ASCII newline and carriage return characters, characters 10 and 13 respectively, may unsynchronize the listing file so that it will not load properly. There are two active options and one sub-menu within the Import Menu. These are as follows: o Save to ASCII: The application currently in memory will be saved to disk as an ASCII listing file. The file name will be the same as that of the parent application, but with an extension of .LST. While the listing is being saved, its progress will be posted on the screen. o Load from ASCII: A standard file name input box will pop up when you select this option. The default input string is "*.LST" which you can edit in the usual manner. When you have selected a file to load, RExL will being to process the file. Note that the format of the file is very strict and you shouldn't edit the ASCII listing, in case the editor doesn't accept it. The listing file will be saved in the current directory (irrespective of where the listing file is) under the same file name, but with an extension for the application image of .RXL and one for the screen file of .SCR. If either of these files already exist, then they will be backed up: The application image being given an extension of .BAK and the screen file one of .BKS. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 49 - o During the loading process, all executable lines (that is screen fields and lines in the application image) will be displayed in a box underneath the progress box which also displays the percentage of the lising file loaded, for your convenience. This is done so that when an error occurs, it can be displayed on screen and edited. o ASCII Options: This is a sub-menu which contains the following two options related to ASCII loading and saving. - Strip unused vars: This is a yes/no toggle option. When set to yes all variables which are listed in the ASCII listing file, but which are not used in the actual code of the application, are discarded and not placed in the newly generated variable list. When set to no, these unused variables are not removed. - Emit screen codes: This is another yes/no toggle option. When it is set to yes, the color codes for the screens in the listing are emitted along with the text of the screen. For purposes of system documentation, this information is generally not needed, and this option can therefore be set to no. 4.4 Using the Editor Once you have selected the Edit option from the main menu, RExL is ready for you to start creating your application. All lines entered are either statements, rules or screens. The rules for entering each line type are laid out in the next three sections. The editor will automatically assign the line connectors, If, AND and OR according to the rules for block connection. That is, the first non-blank line in a rule uses If, the first lines in the remainder of the and-blocks use OR, while all remaining non-blank lines use AND. Blank lines have no connector. A rule may be declared as one pass by pressing <Ctrl-O> within the edit window. Since the one-pass modifier applies to the rule as a whole, the modifier [OnePass] is displayed - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 50 - in the rule name box at the top of the edit window. As with the rule type modifiers, <Ctrl-O> toggles its modifier. 4.4.1 Entering Statements Statements, which include both assignments and logical expressions, are the simplest to specify, by pressing <F4>. However, before RExL will accept a statement, it must be syntactically valid. The statement syntax checker scans the line for invalid syntax, incorrectly dimensioned arrays and incorrectly used functions and variables. When it encounters an error, it signals the location of the error on the input line with an red indicator. A keystroke will clear the error and return control to the editor, where the error can be corrected. If the line is syntactically correct, the syntax checker will recover all variables from the line and add them to the variable list, available on <Alt-V>. Any new arrays found in the statement will be dimensioned to ten elements in all their declared dimensions, although this can be changed through the variable list, explained shortly. In certain cases, when comparing strings and using the logical return values, you may need to bracket the string sub-expression to avoid incorrect parsing. For example, an expression such as a:=10+"a"=a$ will require bracketing since the sub-expression 10+"a" will be evaluated first, since addition has a higher precedence than equality. When the line has been passed as correct, the syntax checker then converts the text into symbolic tokens which are stored more efficiently in memory than text alone. This has a number of side effects: o Variables are converted to internal variable reference numbers: It is for this reason that when a variable is entered a second time, the case in which it finally appears will be the same as that in which was first entered. For example, if you enter an expression such as MyAge:=10 (where MyAge has not been defined previously) and later on enter the expression myaGE=12, then the string myaGE will be converted to the earlier occurrence of MyAge. o Numbers are stored in one of four forms, depending on their size. Whole integers between -127 and +127 - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 51 - inclusive are stored exactly as one byte numbers, whole integers between -32767 and +32767 are stored exactly as two byte integers, whole integers between -2147483647 and +2147483647 are stored exactly as four byte numbers. All other numbers are stored as as eight byte double precision real numbers, to an accuracy of approximately fifteen digits. When you enter a number, it will be converted into the appropriate internal format. Any superfluous, or unstorable decimal places will be discarded. 4.4.2 Entering Rules Rules are the simplest entities to enter in RExL: Any line without a modifier defaults to a rule. When an unknown rule is entered, it is entered into the rule list immediately. As with variables, rules are stored by reference, so that once a rule has been entered, its case cannot be changed. The text of rules themselves may be edited, and the editor will change all references to reflect the new edition of that rule. Rules can take any of the modifiers, BackTo, Not, While, Multi, Single, Zap or a blank modifier. Each modifier modifies the meaning of the rule as explained in the chapter on the language, a blank modifier simply means `call the rule' and do not modify its return value. To set the line's modifier, press <Ctrl-> followed by the initial letter of the modifier. Thus <Ctrl-Z> will generate a Zap modifier. Pressing the key again will remove the modifier and return the rule to its unaltered state. The full list of modifiers and keystrokes is given at the end of this chapter in the key reference. To expand the definition of a rule to include subrules, statements, screens and so forth, press <Tab>. The name of the expanded rule will be placed in the rule name box at the top of the edit window and the hilite bar placed on the first line of the rule. Press <Shift-Tab> to return to the parent rule. Since all rules are stored by reference, the capitalization of a rule name is set when the rule is initially entered, it cannot be changed after this. Whenever the name of a rule is changed (by editing it), all references to it are - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 52 - automatically updated. The editor will not allow the name of a rule to be changed to one which exists already, since it can't determine which rule is referred to. 4.4.3 Entering Screens A screen can be one of five types, [Dialg], [Dsply], [Help], [Menu] or [Print]. The meanings each of these modifiers is explained in the chapter on the screen designer. As with rules, the name of a screen can be changed and will be updated automatically in the screen file as will all references to it in the application being edited. As before, the new name cannot be one which already exists. To enter a screen, press <Tab> or <F10> when hiliting the name of the screen in the edit window. If the named screen does not exist in the screen file already, then you will be prompted to select a screen type from a pop up menu. Because the screen designer is a major and large feature in RExL, it is documented in a chapter of its own. 4.5 Editor Lists At all times, the editor maintains lists of all entities defined within RExL. These are the lists of used and unused rules, used and unused screens and variables. Most of the lists have `hot-links', or special keystrokes which produce lists specific to the item hilited in the first list. The following three subsections tell how these lists are used. When a list is activated, a window, the width of the screen is displayed. The window extends to the second last line of the screen if there are enough elements to fill it, otherwise it sizes itself to produce a window large enough to hold all items. If all the elements cannot be displayed, a scroll bar will be displayed on the right hand edge of the list. The <Scroll-lock> key can be used to move the window using the arrow keys while the contents of the window may be written to a file or the printer using the <Ctrl-P> keystroke. All lists containing rules have a hot-link tied to the <Tab> key. When this is pressed, the editor will quit the list and enter and expand the definition of the hilited rule. This keystroke is present in the normal and unused rule lists, the screen list, and all rule reference lists. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 53 - If a list is terminated by pressing <Enter>, the last hilited item in the list will be pasted into the scrap buffer. Terminating the list any other way (say by pressing <Esc>, <Left-Arrow>, <Right-Arrow> and so on) will not alter the contents of the scrap. 4.5.1 Reference List The reference list of a rule is the list of the rules which reference, or call, the rule currently being edited. The only hot-link in the reference list is the <Tab> key, used to enter a rule's definition. Reference lists are available in the screen list, the rule list and the variable list. All reference lists are generated by pressing <Ctrl-R>. The <Ctrl-R> keystroke can also be used to generate the list of rules which call the current rule. This list performs the same operations as the generic rule reference list above. 4.5.2 Rule List The rule list is the most commonly used list of all and it is for this reason that it is attached to the keystroke of <Alt-Z> or <Shift-F2>. The rule list contains two hot- links, the first is the <Tab> link as explained above, and the second link, tied to <Ctrl-R>, which generates the rule reference list, the list of rules which reference the hilited rule. 4.5.3 Screen List The screen list gives the names of all screens defined in the application and is generated by pressing <Alt-S> or <Shift-F3>. This list includes both used and unused screens. This list has two hot links, the first tied to <Ctrl-R>, generates a screen reference list, the list of rules which use the hilited screen. This reference list has the normal hot-link key of <Tab> to enter a rule's definition. The second hot-link in the screen list is tied to <Tab>: When pressed, the editor will immediately jump to the first occurrence of the hilited screen within the application. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 54 - 4.5.4 Unused Rule List The unused rule list gives the list of rules which are unused in the current application and is generated by pressing <Alt-U> or <Shift-F4>. There are a few minor quirks which you need to be aware of when using this list. Firstly, the list will not contain rules which are used by unused rules but are unused elsewhere within the application. Secondly, rules which are recursive, or use the modified rules from deeper than the first call level of the rule will not be included. To clarify the last point, if a rule called Top Rule called a rule Second Rule which then called Top Rule, all of which were unused by the rest of the application, the unused rule list would not determine that neither Top Rule nor Second Rule were unused. On the other hand, if Second Rule did not call Top Rule, then Top Rule alone would be found to be unused and placed in the list. If you wish to remove unused rules from the application altogether, press <Alt-D> (or <Ctrl-Y>). The hilited rule will be removed from memory and `forgotten' by RExL. If there are rules which were only used by newly deleted unused rules, then these can be listed by exiting from and re- entering the list. To enter the definition of an unused rule, press <Tab> when hiliting the rule. When you are finished editing the definition of an unused rule, press <Shift-Tab> to return to the main rule. 4.5.5 Unused Screen List The unused screen list is generated by pressing <Shift-F5> and is much the same as the unused rule list, with the exception that screens which are used by unused rules are said to be used. Press <Alt-D> or <Ctrl-Y> to delete the screen from the screen file. 4.5.6 Variable List The variable list, on <Alt-V> and <Shift-F6> lists all variables defined within your application. When the list is active, the status line at the bottom of the screen will display the type of the variable and its dimensions, if the hilited variable is an array. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 55 - There is one hot-link in the variable list: Pressing <Ctrl-R> will generate a list of the rules which reference the hilited variable. Note that the variable reference list does not list the rules which contain screens which reference the variable. As with all reference lists, you can go directly to a hilited rule by pressing <Tab> from within the reference list. You can alter the size of an array variable from within the variable list by pressing <Tab> when hiliting the array. The cursor will reappear on the variable status line in the first of the array's dimensions, where the value there can edited. By default, all arrays are dimensioned to a size of ten in all the array's dimensions. 4.5.7 Function List This list contains all internal RExL functions and is generated by pressing <Ctrl-F> or <Shift-F7>. The arguments which the function requires are listed on the status line at the bottom of the screen. There are twelve abbreviations which are used for the twelve different parameter types which may be passed to RExL's function. Table 4.2: Function Parameter Abbreviations Abbreviation Meaning number Numeric expression string String expression variant Numeric or string expression arraynv Variable size string or numeric array array1v One dimensional string or numeric array array2v Two dimensional string or numeric array array3v Three dimensional string or numeric array arrayn$ Variable size string array array1$ One dimensional string array array2$ Two dimensional string array array3$ Three dimensional string array arrayn Variable size numeric array array1 One dimensional numeric array array2 Two dimensional numeric array array3 Three dimensional numeric array Press <Ctrl-F1> to get language help on the function currently hilited. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 56 - 4.6 Other Functions The editor has a number of other functions which do not easily fall into any of the categories listed before. These are given here. 4.6.1 Graphic Rule Display The graphic rule display, generated by pressing <Alt-G>, lists the dependencies of rules upon each other in an easy- to-understand graphic format. When in the display, you can move the hilite bar up and down by in the normal way. Pressing <Tab> will expand the currently hilited rule's definition while pressing <Enter> will paste the name of the hilited rule into the scrap buffer. The easiest way to understand the graphic rule display is to look at an example. [Figure not available in disk manual] When the graphic rule display was called, the editor was in the main rule, the root of the application, so therefore the entire dependency tree will be displayed. In this case, the Main Program consists of three rules linked as follows: If First rule And Second rule And Restart the application In the graphic display, rules connected by AND's are linked by vertical bars, hence the bar on the extreme left of the display connecting these three rules. First Rule contains the following: If First sub rule of 1st rule And Second sub rule of 1st rule Or Or This sub rule of the 1st rule As with the main rule, the first two lines in the first and-block are linked by a vertical bar. When the display generator reaches an OR connector, it terminates the vertical bar and begins a new one. In the case of the First rule, there is only one line in the second and-block, so the vertical bar cannot extend beyond the current line, so it will collapse to give a horizontal bar. The same procedure - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 57 - applies to the Second rule which has the same format as the previous one. Normal rules are colored light gray, while recursive rule calls or rules prefixed with the BackTo modifier are hilited in yellow. In the example above, all rules are colored light gray, except for the third last rule and the final rule in the display, both of which are prefixed by BackTo and are therefore colored yellow. As with all lists, this can be printed to a file or device by pressing <Ctrl-P> and entering a file name. 4.6.2 Miscellaneous keystrokes 4.6.2.1 Cut and paste Beginning with version 2.10 of RExL, blocks of text can be moved around in the editor using the concept of the line buffer. The line buffer operates in a similar way to the scrap buffer on the bottom line of the screen. To copy a block of text, it must be selected and then inserted into the line buffer. The <Alt-M> keystroke is used to set the `anchor' point and further movements of the cursor keys will extend the block in the direction moved. When the desired block has been marked it can be deleted, or cut, to the line buffer by pressing <Shift-Del> or copied to the line buffer by pressing <Alt-M> again. When the line buffer contains text, the triple bar character _≡_, is placed at the left hand end of the editor status bar, just to the left of the normal scrap buffer. Text is copied to, or pasted from, the line buffer by pressing <Alt-C>. The editor will not allow text to be deleted to the scrap buffer if the current rule exists already in the rule stack. 4.6.2.2 Editing keys <Alt-B> places a blank line before the current line, pushing those lines after the current line, down one line. The connector on the line pushed down will change to OR, in line with the rules for connectors. <Alt-D> will delete the current line, pulling all lines after the current line up one line. The line's connector - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 58 - will be changed if necessary. The more normal keystroke of <Ctrl-Y> performs the same function as <Alt-D> <Enter> will act in the same manner as <Down-Arrow>. <Ctrl-Home> moves the hilite bar to the top of the screen, while <Ctrl-End> moves it to the bottom of the screen or the last line in the rule, whichever is nearer. <Ctrl-PgUp> moves the hilite bar to the first line in the rule. 4.6.2.3 Other keys <Alt-X> will attempt to terminate the editor and return you to DOS. If the file being edited has been changed since it was last saved, then you will be prompted to save the file. <Alt-F5> displays the DOS screen, as it was when the editor first started up. <Ctrl-F8> toggles a runtime breakpoint at the current line. The breakpoint will be signalled by a breakpoint character, ■. <F2> will save the current application while <F3> will load a new one. <F9> runs the application and calls up the debugger, prompting the user to save the application if it has not already been done. <Ctrl-F9> runs the application without calling up the debugger. <F10> will enter the screen designer, popping up a screen type selection menu if the screen specified on the line does not already exist in the screen file. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 59 - Chapter 5 Screens in RExL 5.1 Introduction This chapter documents the screen designer and the capabilities of screens in RExL. Screens are an integral part of RExL as a whole and are used for input, output and dialog in general with the outside world. The documentation on the screen designer is divided up into two chapters, the first dealing with the different types of screens available and their specific purpose with the system, while the second deals with the specifics of using the screen designer to produce the screens. Any modifications to a screen in an application are written immediately to disk in the disk based screen file. This allows for screen files which can be arbitrarily large. However, if changes are made to the screen file, and in particular, if the position of a screen changes within the screen file, then the old backup copy of the application image on disk (the ".RXL" file) will not hold a valid copy of your application. The reason for this is that screens are stored in application image files using reference numbers. If a screen's position is changed within the screen file, then the reference number for the screen will be invalidated, and because of the algorithm for squeezing screens into screen files, other screens may be invalidated also. The upshot of this is that whenever a change has been made to a screen file, you should press <F2> from within the edit window to update the application image on disk. This is not strictly necessary, but if you live in an area with frequent power outages, a `dirty' power supply or just simply wish to keep a valid backup at all times, then you do it. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 60 - 5.2 Fields 5.2.1 Introduction A screen field is an area of the screen which has some special property or meaning when the screen is activated in the application. There are five different types of field, some of which are possible in only some types of screen. A table at the end of this section gives the legal and illegal combinations of fields and screens. All fields have certain properties associated with them which modify the behaviour of the field in some manner. The various properties are covered in the next few paragraphs. 5.2.1.1 Field Properties Fields have two colors attached to them. The first is the active color, the color in which a field will appear when it becomes the active field on a screen. The second color is the inactive color which is the color in which they will be displayed at all other times, when they are inactive. By default, all fields have the same active and inactive colors (except for menu fields where one color is the `reverse' of the other, and output fields, which can have no active state). The combination of foreground and background color of a location on screen is generally known as its attribute, to avoid confusion with the less precise term `color' which can be used to refer to the foreground color, the background color or the combination of both. All fields which can display changing information can be specified as left justified (the default), in which case the information to be displayed will be placed flush against the left hand end of the field, or right justified where the information is placed flush right. The justification mode can be selected from the field control menu. The controlling variable of all fields must be a proper LValue, except for output fields where it can be any valid expression. While the screen is being run by the runtime module, the values of the various fields is rigorously kept up to date by global recalculation of all field values. The result of this is that whenever a value is specified for a field, the value is stored immediately and all the expressions in the fields in the screen are recalculated. However, if an application contains a screen with a large number of fields, this recalculation may slow down the - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 61 - screen. To get around this problem, there is a recalculation flag attached to fields to specify whether that field should be recalculated every time. As with field justification, the recalculation state can be selected from the field control menu. In the screen designer, the different field types are displayed using special characters which are removed before display during execution. The following six paragraphs outline briefly the functions of each of the different field types and how they are displayed on screen in the screen designer. Where possible, the initial value of a field will be the value of the field's LValue upon entry to the screen. 5.2.2 Output Fields Output fields are the most common form of fields. They are used to output either string or numeric information at fixed positions and within fixed boundaries. For numeric output, the decimal precision of the output can be specified and defaults to zero places of decimals. Output fields are displayed on the screen using hash symbols, #. The output field expression can be any valid numeric or string expression. Note that string results are output without quotation marks unlike the debugger expression evaluator and watch facility. 5.2.3 Input Fields Input fields are used for input of string and numeric information. Like all other fields except output, the input field expression must be a proper LValue. Numeric input fields can have a decimal precision specified for input. By default, the precision is zero places of decimals but it can be altered via the field control menu. Input fields can be specified as being required, meaning that for strings a non-blank string must be entered, while for numbers, a non-zero number must be entered. Input fields are displayed on screen as a series of question marks, ?, extending to the width of the input area. 5.2.4 Toggle List Fields A toggle list field is a list of string constants through which the end-user can move by pressing <Space> or <Right> - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 62 - to go to the next, or <Backspace> or <Left> to move to the previous choice. There can be a maximum of 100 choices in a single toggle list. Toggle lists are preferable to string input where there are only a small number of valid strings which may be entered. Toggle list fields can use either numeric or string LValues. Toggle lists are displayed on screen as a series of piping symbols, |, extending to the width of the field. 5.2.5 Check Box Fields A check box is a field which only take on a True or False value. Check boxes are useful when you have to implement a boolean choice, for example: whether the user wants to back up some data. String and numeric LValues are valid expressions for check boxes. The value returned to RExL for a checked check box is 1.0 for a numeric LValue and "Y" for a string LValue, while an unchecked check box returns 0.0 to a numeric LValue and "N" to a string LValue. If the check box expression is of string type, then the initial character in the string is used to determine the initial value of the check box field. The characters "Y", "T", "y" and "t" are all taken to mean True and all others are taken as False. A check box is displayed on screen as an open square bracket followed by a space and a close square bracket character: [ ]. When a check box is checked, the space in the center will be replaced by a tick mark √. The value in a check box is toggled by pressing <Space>. 5.2.6 Radio Button Fields A radio button field is a vertical list of choices, one of which must be chosen (it is for this reason that the field is known as a radio button). This field type is used for input of information similar to that in a toggle list field. Radio button fields are displayed as a three character wide column, each line consisting of an opening parentheses followed by a space and a closing parentheses. The current choice of the radio button is denoted by a solid dot placed between one of the sets of parentheses: (). When activated, <Up> and <Backspace> are used to move to the previous member of the radio button list, while <Space> and <Down> are used to move to the next member. Alphanumeric keystrokes (letters and digits) bring the cursor to the - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 63 - first button whose label's initial letter matches the keystroke. Labels are considered to be to the right of the radio button list. Consider the following radio button list: ( ) First Choice ( ) Second Choice ( ) Third Choice ( ) Fourth Choice On entry the radio button will indicate the label First Choice. Pressing the letter `S' will bring move the cursor to the second choice, since the initial letter of the label is `S'. Pressing `F' once brings the indicator to the fourth choice, while pressing it again brings it back to the first choice. 5.2.7 Menu Fields Menu fields are the simplest type of field available in RExL and can only occur in menu screens. They are defined as retangular areas of any size. When in use, the user switches from one field to the next in the same manner as in input, check box, toggle list and radio button fields. As with radio buttons above, entering letters will move the hilite bar to the first field after the currently hilited one to contain the letter pressed in its uppermost and left position. Unlike the other field types, menu fields may contain other fields. You can thus create menus with variable items by placing menu fields over output fields which display the item values. If you so wish, you can place menu fields within one another to give a moving bar type display. Menu screens return a value to the LValue attached to that screen. Internally, the LValue is stored as the first field in the menu screen and can only be changed when you are entering the screen designer, and not from within the screen designer itself. 5.3 Screen Types There are five different types of screen, each designed for a specific purpose. As explained in the Language chapter, - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 64 - each screen has an associated modifier which instructs RExL what to do with the screen when it encounters it in the application. Table 5.1: Screen Types Abbreviation Used for [Dialg] Basic input and output [Dsply] Output with pause [Help ] On-line user application help display [Menu ] Menu choice display [Print] Hard copy output Because modifiers are attached to individual lines rather than to the screens per se, a single screen can be used with more than one modifier. A typical example is a results output screen which can be displayed as a dialog screen, using the [Dialg] modifier and then printed as a print screen using [Print]. As noted above, not all field types are valid in all screens. The following table lists the valid combinations of field types and screen types. Table 5.2: Valid Combinations of Screen and Field Type Output Input Toggle Check Radio Menu Dialog Yes Yes Yes Yes Yes Menu Yes Yes Print Yes Help Yes Display Yes If you try to use a field in a screen which does not support that field type, you may get spurious results. As noted above, menu screens store their LValue in the first field in the screen, thus if you try to convert a non-menu screen to a menu screen, the menu's LValue will become the expression entered for the first field in the non-menu screen. In general, you should only mix screen types which have the same field types available. The next five subsections give details on the use of each screen type. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 65 - 5.3.1 Dialog Screen The dialog screen is the most used of all the screen types. It is the only screen which can contain numeric and string input, check boxes, radio buttons and toggle lists. Input starts from the top of the screen and proceeds to the right and down the screen. When in the screen designer, pressing <Ctrl-S> displays the field sequence number of the field underneath the cursor. The sequence numbers are updated whenever a field is moved, created or copied. <Tab>, <Down-Arrow> and <Enter> are used to move forward one field and <Shift-Tab> and <Up-Arrow> to move back one field. If there is a field directly above and touching the current field, then <Up-Arrow> will move to that field, instead of a field to the right of the upper field. <Down-Arrow> works in the same way. This makes block areas of input more intuitive to use. To terminate the dialog screen, press <Enter> when the final field on the screen is active, or <Ctrl-Enter> from any field. In numeric and string input fields, <End> moves the cursor to the right hand end while <Home> moves to the left hand end. <Ctrl-Left> and <Ctrl-Right> move the cursor one word to the left and right respectively while <Ctrl-U> undoes any changes to numeric and string input areas. If there are a large number of fields on the screen, then you may want to turn off automatic field recalculation to speed up processing of the screen. If there are any string or numeric input fields which are defined as being necessary but are not filled (non-zero for numeric fields), then a message to this effect will be displayed at the bottom of the screen and the missing field will be filled with X's which are removed with the error message when a key is pressed. 5.3.2 Display Screen Display screens are used to display information and to pause for a keystroke. This is to get around having to use a dialog screen with no active fields in it followed by a KBread() statement. The keyboard buffer is not emptied when - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 66 - this screen type is used, so you may need to precede the screen with a KBclear() statement. 5.3.3 Help Screen Help screens are used to implement context sensitive help during screen dialog. The number of help screens available to the user is not limited, although there can only be one help screen available at any one time. Whenever the runtime module encounters a help screen, an internal variable saves the name of the screen, then any subsequent <F1> keystrokes will cause this screen to be displayed. When the help screen has been displayed, RExL waits for a keystroke and then restores the contents of the screen as they were before <F1> was pressed. Once a screen has been saved as the current help screen, that screen will remain current until the next occurrence of a help screen. 5.3.4 Menu Screen Menu screens return a value to a numeric variable attached to the screen and can be used to implement block menus. Menu fields, which can only be used in this type of screen, can be of any size and may be nested inside one another unlike other field types. When a menu field is defined, the field's inactive color is set as described above but the field's active color is set to the `reverse' of the inactive color (for the computer literate, the active color is xor'ed with 7Fh to generate the reverse attribute). This is done so that the end-user of the system can tell which menu field is currently active. When a menu area has been defined on screen, a vertical line of piping symbols, |, is placed on the left hand and right hand sides of the area. When the menu is active on the screen, the piping symbols are replaced by blanks, to give a margin one character wide at either end of the area. When in use, the keys of <Up>, <Down>, <Tab> and <Shift-Tab> may be used to switch between menu fields in the normal way. As with the radio button field as explained above, pressing letters will move the active menu to the field whose first character (starting from the top left of the field and moving right and down) matches the keystroke typed. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 67 - If there are no menu fields in a menu screen, then the screen is displayed and execution continues without pause. As mentioned above, the first field in a menu screen is reserved for the menu screen's LValue. you should bear this in mind when trying to turn a menu screen into another type of screen (or vice versa). 5.3.5 Print Screen Print screens are used to send output to the printing device attached to your computer, which by default is the DOS file PRN file. This default can be changed by using the OUTPUT() command. A print screen may only contain output fields. Although RExL has no intrinsic support for printer effects such as italics, bold and so forth, you can send control sequences to the printer by using output fields which output the required characters. When RExL is printing a screen, it omits all lines containing spaces from the bottom of the screen, to avoid having large blank spaces in the printout. If you want to have print screens of fixed lengths, then you should place some nonblank character at the final line of the screen. For example, if you wish to print out labels of fixed height of (say) 9 lines, irrespective of the contents of the screen, then you should place some unprintable but nonblank character on the final line. The tab character, CHR$(9), is ideal for this and could be placed in its own output field on the last line of the label, or in the inter-label space. 5.3.6 Subscreens Subscreens are identical in function to ordinary screens, the only difference being that they do not occupy the full size of the screen. Subscreens are slightly cumbersome to define: By default, when the screen designer is asked to design a new screen, it assumes that the full screen is required. To get around this, a temporary screen (which will be dumped later) must be created and then the subscreen designed and saved as a block using the !Save! option in the block menu. The procedure to define a subscreen is as follows. Type in some temporary and unique screen name into the editor and press <F10> to select the screen type. The screen can then be designed as normal. When the design has been completed, - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 68 - the area of the subscreen can be marked out and saved to disk as the appropriate screen type. As this point, the screen designer can be terminated and control returned to the editor. Since the screen was not saved, the line will have reverted to being a rule which can then be deleted, since it was only temporary anyway. The subscreen saved from within the screen designer is now present in the screen list and can be inserted into the application listing as a normal screen. To force the screen type, the screen designer will have to be re-entered by pressing <F10> on the screen name and by selecting the appropriate screen type. If changes are made within the screen designer to a previously defined subscreen, then upon exit or saving of the screen, the screen designer will ask if the screen is to be saved at its previous size or at full screen size. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 69 - Chapter 6 Using the Screen Designer 6.1 Starting the Screen Designer The screen designer is fully integrated into the editor and can be accessed through the <F10> key. Before you can enter the screen designer and create a screen, you must supply a screen name for the screen so that it can be entered into the screen file on disk immediately. Once a new screen name has been entered, the screen type must be defined using the screen type menu on <F10>. This is a five item pop-up menu which lists the five different screen types. The items are listed in the order in which they are most commonly used. ┌───────────┐ │ Dialog │ │ Menu │ │ Print │ │ Help │ │ Display │ └───────────┘ The screen type is selected in the normal manner by using the up and down arrow keys and pressing <Enter>. When a screen has been saved and the screen designer terminated, the normal editor screen will reappear and the screen name previously entered will be prefixed with one of the five screen modifiers as described above. The action of the <F10> key is slightly different when applied to a line containing the name of a screen and the type of the screen as reported by the line's modifier. In this situation, the screen designer is activated directly without going through the screen type menu. In order to change the type of a screen (for example from a display screen to a print - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 70 - screen), you must enter the name of the screen with no modifier and then press <F10>. Once the line modifier has been entered, the screen designer can be reactivated by pressing <Tab> on the screen name, since the editor knows that this line refers to a screen and not a rule. If the menu screen type has been selected from the screen type menu, a dialog box will be displayed prompting for the menu variable (which can be any proper RExL LValue) associated with that screen. As explained above, when the menu screen terminates, the screen's menu variable will be set to the field number of the field which was current when <Enter> was pressed. When the menu variable has been entered, the screen designer will start. When the screen designer is entered for the first time, the screen will be filled with the half-tone character (ASCII 177) colored in light gray on a black background (unless the `Print' screen type was selected, in which case the screen will be blank). The the cursor will be in the top left hand corner of the screen and screen designer is now ready for input. If there is a default screen defined (through the Edit|Default screen menu option) then the contents of the screen will be loaded automatically. If the screen designer is started with a previously defined screen, the screen designer will remove fields which would be invalid in the newly chosen screen type. For example, if a screen which was previously of type `Menu', and it were then opened as a `Dialog' screen, then the menu variable and the menu fields would be stripped from the screen. This feature should be borne in mind when saving screens. In general, cross-type screen translation should be avoided for this reason. 6.2 Basic Design The cursor is moved in the screen designer using the standard arrow keys <Up>, <Down>, <Left> and <Right>. In addition to these keys are the following: - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 71 - Table 6.1: Screen Designer Cursor Keys Key Moves cursor <Home> to start of line <End> to end of line <PgUp> to top of screen <PgDn> to bottom of screen <Ctrl-Left> left one word <Ctrl-Right> right one word <Ctrl-Home> to top of screen <Ctrl-End> to bottom of screen <Ctrl-PgUp> to top left hand corner of screen <Ctrl-PgDn> to bottom right hand corner of screen <Tab> right ten characters <Shift-Tab> left ten characters <Enter> to beginning of line The action of the <Enter> key is slightly more complex than simply moving to the start of the next line: If there is a box character on the next line underneath and to the left of the cursor, then the cursor will be placed on the right hand side of the box character. This behaviour makes it easier to enter text in boxes on the screen. 6.3 Fields in the Screen Designer The screen designer supports the use of six different types of fields as explained in the previous chapter. In general, a field definition can be initiated by pressing <Ctrl> and the initial letter of the field type which you wish to define (for example output fields are attached to <Ctrl-O>). A field definition menu is attached to <Ctrl-F>, from where you can select the field type to define, if you can't remember the different field types. When defining a field, the area marked out on the screen is painted in `reverse' colors to hilite it against the background. The location on screen where the field definition was initiated acts as an `anchor' point which remains fixed while the field is defined. Initially, the cursor is placed on the anchor point and can be moved about the screen using the arrow keys plus the four other cursor keys <Home>, <End>, <PgUp> and <PgDn>. <Enter> is used to terminate the field definition. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 72 - The menu field is the only field type which can be of arbitrary size so in all other field type definitions, the movements of the cursor are limited to avoid creating improper fields. The following table lists the valid sizes of fields: Table 6.2: Valid Field Sizes Vertical Movement Horizontal Movement Output Fixed height of one Yes Input Fixed height of one Yes Toggle Yes Fixed width of 3 Check Fixed height of one Fixed width of 3 Radio Yes Fixed width of 3 Menu Yes Yes When the field has been defined, a dialog box will appear (not applicable to menu fields) into which the expression associated with that field is entered. While in this dialog box, you are free to use the scrap buffer as normal, even though it is not displayed. The function and variable dictionaries are also available. Every field on the screen has a field number associated with it. This number codes for the order in which the fields are to be evaluated when the screen is run by the runtime module. The fields are numbered sequentially from zero, increasing moving to the right and then down the screen. This behaviour is compatible with the IBM- and MicroSoft- defined CUA standard for user interfaces. Whenever a field is created, moved or deleted, the screen sequencing numbers are recalculated, this may cause delays of the order of a half a second or so on XT-class machines. In the current release, there is no way to alter the sequencing order of fields in the screen. In any one screen there may be up to 128 fields. Beyond this limit, the amount of time required for processing the fields becomes noticeable. It should also be noted that any screen which uses more than 128 fields will be cluttered and should be redesigned to use less fields. The methods for entering the various fields are presented in the next six sections. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 73 - 6.3.0.1 Output <Ctrl-O> is used to define an output field. Output fields can be up to eighty characters wide, the width of the screen, and are one character in height. Only horizontal movement is permitted while defining an output field. When the field has been marked out, a dialog box will appear prompting for an output expression. This can be any valid RExL expression and it will be syntax checked before it being accepted by the designer. When a valid expression has been entered, the marked area will be replaced with hash symbols, #, to denote an output field. 6.3.0.2 Input <Ctrl-I> is used to define an input field. Input fields can be up to eighty characters wide and are one character in height. The input expression must be a properly formed LValue. As with output expressions, the designer will not accept an improper expression. Input fields are denoted by question marks, ?. 6.3.0.3 Toggle <Ctrl-T> is used to define a toggle field. These fields can be between seventy seven characters and six characters (inclusive) in width and are one character in height. The toggle expression must be a proper LValue. You can have up to one hundred choices occupying up to four thousand characters of storage in an individual toggle choice field. When the field has been defined, two dialog boxes will appear, the upper one for the toggle list LValue and the lower for the list of choices. A field LValue, which can be either string or numeric, must be entered before the individual choices can be. As before, you are not permitted to enter an invalid LValue. When a valid one has been entered, the cursor will move to the second box, labelled Choices. The second box will be of the same width as the toggle list field, so that strings which would not fit in the field are not allowed. The strings are entered in the order in which they are to appear in the field when it is activated. An individual toggle list item can be deleted by pressing <Alt-D> or <Ctrl-Y>. The list entry is terminated by pressing <Enter> on an empty list item and it is for this - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 74 - reason that empty toggle list items are not allowed. The cursor can be toggled between the two windows by using <Tab> and <Shift-Tab>. When the field has been defined, the marked area will be replaced by a series of piping symbols, |. 6.3.0.4 Check <Ctrl-C> is used to define a check box field. Since this field can have only one size of three characters wide by one high, the LValue dialog box will appear immediately prompting for an LValue which may be either string or numeric in type. When the LValue has been entered, the marked are on the screen will be displayed as a set of square brackets separated by a tick, [√]. 6.3.0.5 Radio <Ctrl-R> is used to define an radio button field. Radio button fields have fixed widths of three characters but may be as high as twenty-five characters, the height of the screen. The radio button LValue must be a numeric expression and not a string expression. When the field has been defined, the marked area will be replaced by a vertical block of sets of parentheses separated by the center dot character. 6.3.0.6 Menu <Ctrl-M> is used to define a menu field and can only be used in menu screens. Menu fields can be of arbitrary size and may be nested within one another, unlike all other field types. Since, in menu screens, the menu expression is entered when the screen itself is entered and is therefore constant for all fields, there is no menu expression dialog box associated with menu fields. So, when the menu area block mark has been terminated by pressing <Enter>, the vertical edges of the block will be marked with piping symbols, |, and control will return to the main screen designer directly. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 75 - 6.4 Block Operations Blocks are rectangular areas of the screen which can be defined and then used for various operations. A block is marked by pressing <Alt-M> and then moving the cursor in the same manner as that used during field definition. For those more familiar with Sidekick and the Borland-type editors, the keys <F7> and <F8> may be used to start and end block definition. When a block has been defined, the block menu, which contains nine items, will appear in the top left hand corner of the screen (unless it has been moved). There are nine separate operations selectable from the block menu which may be carried out on marked blocks, and these are covered in the next nine sections. Note that if the block contains a portion of a field, then certain operations are not allowed since they would have no meaning when applied in those circumstances (for example, moving and copying portions of a field). If these are attempted, then the screen designer will display an error to the effect that the area crosses fields. Once a block has been defined and some block operation carried out upon it, it may be re-marked for further operations by pressing <Alt-R>. Typically, this is useful when a box has been drawn which then needs to be painted. 6.4.1 Block Painting This option is used for setting the foreground (ink) and background (paper) colors of the defined block. When this option is selected, the following paint box appears: [Figure missing in disk manual] The color of the foreground is altered using the <Up> and <Down> keys and is tracked in the left pane of the paint box window by a gray square. The background color tracked in the right hand pane with two center dot characters and is changed with the <PgUp> and <PgDn> keys. The row of `x' characters at the bottom of the paint box display the combined foreground and background colors. On the EGA, VGA and most CGA systems, the screen designer can make use of the flash-intensity bit. This allows the use of sixteen background colors instead of eight, at the expense of flashing. This bit can be toggled on and off by pressing - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 76 - <Alt-T>. If the system which the editor is running on supports this feature, then the lower eight colors in the right hand pane will be `brightened'. These can then be selected in the same manner as ordinary background colors. Note, however, that some early CGA adapters do not support this, with the result that what should have been displayed in intense background will in fact be displayed as flashing. The <Alt-T> keystroke can be used anywhere within the screen designer and is not limited to the paint box. If the block area being painted covers a field or part of a field, then the attributes of the field will be updated to the new colors. As with all windows in RExL, the paint box can be moved by pressing the <Scroll-Lock> key, if it obscuring something. When the desired combination of foreground and background colors has been reached, <Enter> will terminate the paint and make the colors permanent. 6.4.2 Align When the align option is selected, the marked area will be moved from its old location and placed at the horizontal and vertical center of the screen from where it can be moved using the normal arrow keys. Pressing <Enter> will make the alteration permanent. In all cases where blocks are moved from one location to another in the screen designer, the attributes of the screen underneath the original block are left untouched and are copied, along with the character information inside the block, to the new location for the block. It is not possible to align blocks which contain portions of a field. 6.4.3 Box The box option is used to draw boxes around the marked area on screen. On selection, the following box menu appears: [Figure not included in disk manual] The first option in the menu selects whether the box is to overwrite the contents of the box (but leave the fields inside intact) or whether the box is to overlaid around the edge of the area leaving the interior untouched. The option - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 77 - can be toggled by pressing <Enter> on it. If the overlay option is selected, then, if possible, the box will link up with any boxes which impinge upon the marked area. To draw a box of a particular type, hilite a suitable border type and press <Enter>. The box will then be drawn on screen. If the screen is destined for use with a printer (such as a print screen), then, unless all printers which may be used with the system support them, the first five box edge types should not be selected, since few printers support the line draw characters in their native mode. When defining a block for use with this option, it is permissible to include portions of a field within the block, although those parts of the box which would cut the fields are removed. Alternatively, boxes can be drawn directly by using the <Alt-B> keystroke. When this keystroke is pressed, the screen designer again enters its block-define mode and the extent of the box is drawn on the screen. When the desired box has been drawn, it is selected using <Enter> and the box type selection menu appears as before. 6.4.4 Delete The delete option is used to delete a marked block. As with the align and move options, the attributes of the originally marked area remain unaltered after the operation. Any fields which are fully within the block are also deleted and the remaining fields are re-sequenced to take account of the new field layout. While the block is being marked, the <Alt-D>, <Del> and <Ctrl-Y> keystrokes may be used to delete the block immediately, without having to go through the block menu. 6.4.5 Move The move option is used to move a marked block. The marked area cannot cross any fields since attempting to move a portion of a fields has no meaning. When the option has been selected, the cursor will disappear and the screen designer enters its block move mode. The block may be moved using the <Up>, <Down>, <Left> and <Right> keys. Pressing <Enter> will terminate the move. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 78 - If the area where the block is to be placed contains any fields, then the fields will be deleted and the field sequence will be regenerated. If the area crosses any fields, then the move will be terminated with an error. When the block has been placed successfully, the character information is removed from the old location of the block while the attributes are left as they are. 6.4.6 Copy The copy option is substantially the same as the move operation above, with the single difference that when the destination is selected, the contents of the original block are left unchanged and new fields are created in the destination. If there are a large number of fields on the screen, then care should be taken that the limit of 128 fields is not reached while copying blocks. If it is reached, then an error to this effect will be displayed and the copy terminated with the fields remaining to be copied being left uncopied. 6.4.7 Fill The fill option in the block menu is used to fill a defined area with a particular character. When the option is selected, the character fill selection box appears on the screen, again, in the top left hand corner of the screen unless it has been specifically moved. [Figure not included in disk manual] The character to fill the block is hilited in the fill selection box in yellow foreground on a magenta background. The normal arrow keys are used to move the selection bar around the list while <PgUp> and <PgDn> are used to move from one group of 64 characters to the previous and next pages respectively. <Enter> is used to select the character to fill the defined block with. If the block contains any fields, then these will be redrawn when the fill operation is finished. The foreground and background colors are left unchanged by filling the block. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 79 - 6.4.8 Save This option is used to save a block to the screen file. This feature is mainly used for creating pop-up menu type displays. When this option is selected, a dialog box will appear, prompting for a name under which to store the block in the screen file. When a name has been entered, the screen designer checks to see if that name already exists in the screen file. If the name is unique, then the block is saved immediately, otherwise, a yes/no menu will appear, asking whether the previous version of the screen should be overwritten with the new one. Selecting the `yes' option from this menu will cause the marked block to be written to the screen file in place of the old one. Once the screen has been saved, it can be read and modified like any other full sized screen. Detailed information on the use of small screen blocks can be found in the section on sub-screens further on in this chapter. 6.4.9 Under shadow The final option in the block menu is used for drawing `shadows' which appear `underneath' marked blocks on the screen. This option is most commonly used for hiliting some important information in a box on the screen by making the box stand out against the background. The undershadow effect is achieved by painting the area to the right of and below the marked block in a light gray foreground color on a black background. The undershadow effect works best when applied on a bright background. Overuse of this effect should be avoided since it loses its emphasis easily. 6.5 Sub-screens Sub-screens are created using the save block procedure as described in the previous section. They are mainly used for creating pop-up menus and other types of pop-up queries. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 80 - The easiest method to create a pop-up sub-screen is as follows: Enter the screen designer at the screen where the pop-up will appear and create the pop-up, mark the area and then save it as a block. Exit from the screen designer, but do not save the parent screen permanently when requested to. Return to the location in the listing where this pop-up will be used and then call it as a normal screen. When the runtime module runs the saved block of screen, it will only load that portion, leaving the rest of the screen as it was before the screen was called, thus creating the effect of a pop-up screen. The screen designer treats sub-screens in almost exactly the same manner as normal full-sized screens, the only differences being as follows. Firstly, upon entering the screen designer with a sub-screen, the sub-screen will be loaded at the same co-ordinates on the screen as it was saved from, while the rest of the screen will be painted with the normal background half-tone character. Secondly, when exiting from the screen designer, instead of the normal `Do you want to save the screen ?' prompt, the prompt `Screen was originally smaller. Save as:' will appear. This menu has three options in it: Original area, Full screen, and Return to editor. The first option will save the original screen block to disk, the second saves the entire screen to disk in place of the original sub-screen, while the final option quits the screen designer entirely and return control to the editor without saving the screen. A minor point to note is that attempting to print sub- screens will not produce the expected results, since the rest of the screen currently on display will be included with the output. 6.6 Field control menu <Ctrl-F> has two uses in the screen designer, which one is used depends on whether the cursor is over a field or not. When the cursor is placed on a field, <Ctrl-F> will bring up the field modification menu, described in this section. When the cursor is not over a field, then <Ctrl-F> will pop up the field type definition menu, described in the next section, listing the six field types from which one can be chosen. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 81 - The field control menu, popped up by a keystroke of <Ctrl-F> while the cursor is hiliting a field, controls the properties attached to that field. The field control menu is slightly different for each field type on account of the differing requirements for each. In total, there are nine properties which may be attached to each of the six different field types as indicated as follows: Table 6.3: Valid Field Attributes Input Output Toggle Check Radio Menu Active color Yes Yes Yes Yes Yes Yes Inactive color Yes Yes Yes Yes Yes Delete Yes Yes Yes Yes Yes Yes Expression Yes Yes Yes Yes Yes Recalc Yes Yes Yes Yes Yes Justify Yes Yes Yes Width Yes Yes Yes Yes Necessary Yes Precision Yes Yes Validate Yes The field control menu for a particular field type consists of the options ticked in the table above underneath the fields. The next nine subsections give the meanings of the items in the field control menu: 6.6.0.1 Active color The active color of a field is the attribute which is used to color the contents of a field when that field is active. All fields, except output fields, have active colors. When this option is chosen from the menu, the standard paint box appears and the field attribute can be selected from this. 6.6.0.2 Inactive color The inactive color of a field is the attribute which is used to color the contents of a field when that field is inactive. All fields, including output fields, have active colors. When this option is chosen from the menu, the standard paint box appears and the field attribute can be selected from this. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 82 - 6.6.0.3 Delete This option will delete the hilited field from the screen and perform a screen field resequencing. Pressing <Alt-D> while hiliting a field in the screen designer has the same effect as choosing this option. 6.6.0.4 Expression The expression attached to a field can be edited when this option is selected. The edited field expression will be checked for correct syntax before it can be accepted by RExL. When the cursor is hiliting a field, <F10> can be used as a shortcut keystroke for this function, while <Alt- F> will simply display the field expression on the bottom of the screen. For toggle fields, the choices may also be altered. 6.6.0.5 Recalc Under normal circumstances, the runtime module will automatically recalculate all fields in a screen whenever the contents of one field are modified. If there are large number of fields in the screen, then this may slow down the operation of the screen designer. Toggling this option on and off will enable and disable the automatic recalculation of the hilited field. 6.6.0.6 Justify Normally, the contents of fields are left justified, that is, placed flush against the left hand end of the field. This option can be used as a toggle to toggle the placement between the left and right ends of fields. Note that during numeric input in input fields, the number is always justified right. When input is finished in the field, the result will be justified as specified by this flag. 6.6.0.7 Width The width of a field can be altered using this option. When it is selected, a block will appear of the same size and shape of the field. This can then be changed in the same manner as ordinary block definition. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 83 - When a suitable size has been chosen and <Enter> has been pressed, the screen designer will check to ensure that the new field does not cross any earlier fields. 6.6.0.8 Necessary String and numeric input fields my be defined as being `necessary' for the proper completion of the screen. If this flag has been set, then a zero value, for numeric fields, and an empty string value, for string fields, will not be allowed as valid input. The runtime module will hilite the unfinished field in red, fill it with X's and post an error message on the bottom of the screen and return the end-user to the field. 6.6.0.9 Precision Numeric input and output fields can have an optional decimal precision supplied. This will be the number of decimal places to be displayed or input when the runtime module processes the field. 6.6.0.10 Validation Numeric and string input fields may be validated as date and time strings by toggling the validation type between `None', `Date' and `Time'. If the user enters a string, then it will be checked for validity by the runtime module. If the string is found to be invalid, then execution will not proceed until a valid string is entered. The format checked will be the format current on your machine, or that set up by a call to the DTformat() command. Note that the null date string, "00/00/0000" is considered to be a valid date. If you want to filter out this date, then you should set the `necessary' flag. 6.7 Miscellaneous Functions 6.7.0.1 Changing Field Types The <Ctrl-> key combinations noted above for defining fields also have another use in changing a field from one type to another. For example, pressing <Ctrl-O> when the cursor is hiliting an input field will change that input field to an output field. The exact procedure is as follows: When the - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 84 - <Ctrl-> key combination is pressed, the screen designer looks to see if the cursor is placed over a field, if it is, then the field type is changed to that specified by the keystroke and the field definition routine is called. The width of the field can then be changed. Pressing <Enter> will terminate the width definition and bring up the field expression dialog box (or both of them if the new field is a toggle field). The field changing facility is most useful when changing a screenful of input fields to output fields. 6.7.0.2 Field Utility Keys <F10> is used to edit a field expression, when the cursor is on a field. This function is placed on a special key of its own, since it is used regularly. If the cursor is not over a field, then this key has no effect. The <Alt-F> keystroke can be used to display the expression associated with the cursor field. When this keystroke is used, the expression is only displayed and cannot be modified. <Alt-D> is used to delete the field underneath the cursor. As with <F10>, this keystroke has no effect if there is no field underneath the cursor. The <Ctrl-S> keystroke is used to display the screen status on the bottom line of the screen. The status display contains four items of information: Displayed from left to right, these are the current cursor position in (x,y) format with (0,0) at the top left hand corner. The next two sets of coordinates give the size of the currently defined block (if no block has been defined, then the full screen is used). The `Fields' display gives the number of fields defined in the screen (the second digit) while the first digit gives the sequence number of the field underneath the cursor, or 0 if there is no field there. The type of the hilited field is displayed beside the sequence number. The final display gives the amount of free memory left to the screen designer. For proper operation, this figure should be above 10k. 6.7.0.3 Line Drawing The line drawing feature of the screen designer is used to draw lines on the screen using the IBM ASCII characters between 179 and 218 inclusive. When <Alt-L> is pressed, the designer enters line draw mode and the cursor is backed by a - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 85 - `reverse' attribute block to emphasise the fact that the screen designer has changed mode. When <Alt-L> is pressed, the line draw menu appears in the top left hand corner of the screen: [Figure not included in disk manual] The first option in the menu toggles between overlay and overwrite modes (explained below) while the other options specify the type of line to be drawn. The normal arrow keys and <Space>, to move right, are used to move the head of the line about the screen. When drawing a line, the character underneath the cursor is not updated until the cursor is moved. This needs to be done because the exact character required depends on the next direction of travel of the cursor. The line draw mode can operate in one of three modes: o Overwrite mode, where the line being drawn does not link up with any previous line on the screen. o Overlay mode, where the line does link up with lines already existing on the screen. Note that not all combinations of line draw characters can be displayed using the ASCII character set, in these cases, the current line draw type will take precedence over older lines. o Delete mode, where the character underneath the cursor is deleted. This option is most useful for deleting old lines from the screen. The <Ins> key is used to toggle between overlay and overwrite modes, with the cursor being an underline in overlay mode and a half-box in overwrite mode. The <Del> key is used to toggle delete mode on and off. In delete mode, the cursor is placed in the upper half of the character box. While the line is being drawn, the shape of the line being draw may be changed using the <Alt> key in combination with the digits 1 to 4. The following table summarizes the keystrokes valid in line draw mode: - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 86 - Table 6.4: Keys in Line Draw Mode <Up> Move up <Down> Move down <Left> Move left <Right>, <Space> Move right <Enter>, <Esc> Terminate line draw mode <Ins> Toggle overlay and overwrite mode <Del> Toggle delete mode <Alt-1> Set horizontal line emphasis to one line <Alt-2> Set horizontal line emphasis to two lines <Alt-3> Set vertical line emphasis to one line <Alt-4> Set vertical line emphasis to two lines 6.7.0.4 Other Editing Keys <Ctrl-Y>, used to delete lines, has two functions. When it is first pressed, it deletes all characters and fields to the left and right of the cursor up to, but not including, the nearest box characters. If it is pressed again immediately, then the entire screen line will be deleted from the left edge to the right edge and the lines underneath will be pulled up by one character. Note that <Ctrl-Y> must be pressed twice in succession with no intervening keystrokes for the entire line to be deleted. <Del> is used to delete the character underneath the cursor. All characters up to but not including the next box character to the right of the cursor will be move one character to the left. If <Del> is pressed over a box character then the box character itself will be deleted. <Backspace> deletes the character to the left of the cursor and moves the cursor one character to the left, moving all characters to its right, up to but not including the nearest box character, one character left. 6.7.0.5 Lists in the Screen Designer The editor's three most commonly used lists are also available in the screen designer. These are the variable list on <Alt-V> and <Shift-F6>, the rule list on <Alt-Z> and <Shift-F2> and the screen list on <Alt-S> and <Shift-F3>. The hotkey reference lists which are available in the main editor are not available when these lists are requested in the screen designer. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 87 - 6.7.0.6 Miscellaneous Keys The <F2> keystroke will save the screen to the screen file. If the screen was originally a sub-screen and not a full sized screen, then the prompt `Screen was originally smaller. Save as:' will appear with a three option menu, instead of the normal `Do you want to save the screen ?' prompt. This feature is explained in the section on sub- screens. <Alt-X> and <Esc> are used to exit from the screen designer and to return to the main editor. As before, if the screen has been altered, then you'll be prompted to save it before continuing. All keystrokes greater or equal to the space character and less than or equal to an ASCII code of 255 are placed directly onto the screen. If insert mode is active, then all characters to the right of the cursor will be moved one character to the right, with the rightmost character being lost. If insert mode is not active, then the character underneath the cursor will be deleted. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 88 - - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 89 - Chapter 7 The Runtime-Debugger 7.1 Introduction This chapter covers the functions and capabilities of the debugger module in depth (when we refer to the debugger in this chapter, we mean the runtime-debugger module as a whole). The interface used in the debugger is much the same as that in the editor, so you shouldn't have much trouble using it. The debugger-specific keystrokes are largely the same as those used by the Borland integrated debuggers, so if you have used those, then a quick read through this chapter should be sufficient. 7.2 Debugger Basics The debugger is started by typing `rexlrd' at the DOS prompt. Contrary to the requirements of the editor, you must supply a file name on the command line. If you omit the file name, then a few lines of command line help will appear. In the current release, there are three command line parameters which can be supplied to the debugger, these will be covered at the end of the chapter. Unlike the editor, the debugger does not read or generate a configuration file. The debugger can run in either of two modes: The first is run mode, in which the application is executed without stopping between rule calls, statements and screens. The second mode is debug mode, in which the full screen debugger controls the execution of the system. Debug mode is used if you select the option Debug application from the Run menu in the editor, or if you press <Alt-D> while the application is executing in run mode. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 90 - There are a few terms which you need to understand before you continue with the rest of this chapter. These are explained here: o Step and Trace: An application is stepped or traced when the runtime portion of the module gains control of the application and executes some portion of it. o Watch: A watch is an expression, visible in the watch window at the bottom of the screen, which is evaluated every time the debugger module is given control of application execution. When you enter debug mode, you will be presented with the main debugger screen (note that you can't have all the menus pulled down at once, as they are here! The dots and arrows indicate where the menu is normally displayed): [Figure not included in disk manual] The bar at the top of the screen has four pull down menus. In the same manner as the editor, these can be activated by pressing the left and right arrow keys to move from one to the next, and pressing the enter key to select the hilited menu. Press <Esc> to return to the code window from the menus. To the right of the four menu titles, is the name of the RExL file which is currently being debugged. The third last line on the screen is the debugger status line, which has the same function and features as the editor status line in the editor. Underneath the debugger status line is the watch window (blank above) where watches are kept. On start-up, the watch window is one character high, but this will grow and contract as watches are added and removed. The bottom line of the display lists some of the short-cut keystrokes which can be used in the debugger. The Code Window is above the status line and displays the rule currently being executed. Cursor movement in the code window uses the same keys as in the editor. The four menus on the main horizontal menu bar have contents as follows: - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 91 - 7.2.1 File menu ┌────────────────────────┐ │ Return to editor │ │ OS shell │ │ Quit │ └────────────────────────┘ The file menu has the following seven options: o Return to editor: This option will return control to the editor, loading the application currently being debugged. o OS Shell: If you want to run a DOS command, but do not wish to exit from the debugger permanently, choose this option to go into a DOS shell. While you are in the shell, you should not, under any circumstances, run any T&SR programs (such as Sidekick, ScrGrab and so forth), since these programs change critical area of the computer's memory which may cause it to crash unpredictably when you return to RExL. When you are finished in the shell, type `exit' at the DOS prompt to return to RExL. o Quit: This choice will quit from the debugger and return you directly to DOS, irrespective of whether you started the debugger from within the editor or not. 7.2.2 Debug menu ┌───────────────────┐ │ Watch │ │ Evaluate │ │ Run │ │ Step │ │ Trace │ │ Halt here │ │ Breakpoint │ │ Animate │ └───────────────────┘ All of the options in this menu are also available through hot-key short-cuts. When you become familiar with the debugger's keystroke map, you'll probably not need to use this menu. There are eight options in this menu: - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 92 - o Watch: This option, which is also available via the hot-key o <Ctrl-F7> or <Ctrl-W>, controls the entry of new expression watches into the watch window at the bottom of the screen. The procedure for entering watches is covered in detail in the next section. o Evaluate: Selecting this option, also available through <Ctrl-F4> or <Ctrl-E>, causes an expression evaluation box to appear. This is also covered in the next section. o Run: This choice will return the debugger to run mode and will not return control to the debugger, unless it meets a breakpoint or you press <Alt-D>. Pressing <F9> is equivalent to selecting this choice. o Step: This menu choice is identical to pressing <F8>. o Trace: This choice is identical to pressing <F7>. o Halt here: This option, also available by pressing <F4>, will set a temporary breakpoint at the line currently hilited in the code window. When execution reaches the line, the debugger will regain control and the breakpoint will be cleared. o Breakpoint: This option (also on <Ctrl-F8>)sets a breakpoint at the line hilited in the code window. Whenever execution reaches this line, the debugger will regain control. o Animate: This choice (also on <Alt-F4>) will cause the debugger to emit a trace instruction at variable intervals, so that the debugger appears to control itself. Pressing any key while animating will return control to the user. 7.2.3 Lists menu ┌────────────────────┐ │ Rule list │ │ Screen list │ │ Unused rule list │ │ Unused screen list │ │ Variable list │ │ Function list │ - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 93 - │ Call stack │ └────────────────────┘ This menu gives you access to all the lists of entities which are defined the current application. Most of the lists have special `hot-links' to other, more specific, lists. These are mentioned briefly at the end of this subsection and covered in more detail further on. All of these lists are also available via hot-keys from within the main editor window. Consult the section on editor keys for more information on this. The lists run menu has the following six options: o Rule list: This list contains the names of all of the rules which are currently defined in your application. o Screen list: This list contains the names of all screens defined in the currently active screen file. o Unused rule list: This list shows all rules which, although defined in the normal way, are not actually referenced by the application. Pressing <Alt-D> within this list will delete the unused rule from the application. o Unused screen list: This list gives all screens which are not referenced in the current application. As with the unused rule list above, press <Alt-D> to delete the unused screen from the list and free up the space it occupies within the screen file. o Variable list: This list contains all variables. The status line at the bottom of the screen displays the type of the variable, whether numeric or string, and whether it's an array or a simple variable. o Function list: This list contains all the functions available in RExL. Press <Ctrl-F1> for help on the hilited function. o Call stack: The call stack is the list of rules which are currently executing. The most recent call is at the bottom of the list. The `Main Program' rule is always at the top of the list. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 94 - All the list windows are movable by pressing <Scroll-Lock>, using the arrow keys to position and pressing <Enter>, <Scroll-Lock> or <Esc> to terminate the window move. Note that all lists in RExL feature helix searching. You can also output the contents of any list to a file (or the printer) by pressing <Ctrl-P>, as in DOS. If you terminate any of the lists by pressing <Enter>, then the choice which you selected from that menu will be placed into the scrap buffer, ready for pasting using the <Shift- Insert> keystroke. 7.2.4 Options menu ┌───────────────────────┐ │ Load macros │ │ Save macros │ │ Beep off │ │ Function lower case │ │ Exploding windows off │ │ Screen swap: smart │ │ Repaint screen │ └───────────────────────┘ The options menu controls various system parameters and features not directly connected to the editor per se. o Load macros: Any macro definitions you define in the editor may be saved to disk for later retrieval using this menu option. The macro file format is constant across the RExL product range, so that macros defined in the editor may be used in the debugger or in the database manager and so on. Macros are explained in more detail at the beginning of this chapter. o Save macros: This option allows you to save macros which can then be reloaded at some future time using the load option above. o Beep off: By default, RExL beeps whenever it encounters an error. This beeping can be toggled on and off by selecting this option. o Function lower case: By default, all functions in RExL are displayed in their natural case. This is that functions which are members of families are displayed with the first two or three letters capitalised, while the miscellaneous functions are - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 95 - entirely capitalised. This option is used to toggle between upper (or partially upper) case function name display and lower case. o Exploding windows off: In its normal state, all windows in RExL open instantaneously upon activation. This option can be used to make windows `grow' to full size on the screen. This is only a visual effect and has no effect upon the application. o Screen swap on: Whenever the debugger is stepped or traced, the debugger will swap its own screen with that of the application running underneath it. If your application does not access the screen, then you can toggle this option to `None' to disable the screen swap. o Alternatively, you can set the mode to `Smart', when RExL will check the line about to execute to determine if the line contains an expression which could change the screen. If this is so, then the screen will be swapped, but not otherwise. Smart screen swapping is the default screen swap mode. If, when screen swap is off, your application accesses the screen, the change will be lost when the debugger regains control of execution, possibly with a garbled screen. o Repaint screen: This option is used to restore the debugger screen after it has become corrupted. Corruption of the debugger screen happens when screen swap has been disabled during a screen access by the application. 7.3 Using the Debugger The familiar keystrokes of <Up>, <Down>, <Tab>, <Shift-Tab> and so on, are all supported in the debugger as they are in the editor. While designing the debugger, we have tried to strike a balance between its functionality and size. It is for this reason that, although the <Alt-Z> keystroke generates the rules list as in the editor, there are no hot-links to the other features, such as rule reference and so forth. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 96 - The following is a typical debugger screen: [Figure not included in disk manual] As with the editor, the status line (this time on the third last line) shows the amount of memory remaining free for the runtime module to use. To the right of this is the level display, showing the depth which the debugger has reached. There are two differences to the layout of rules in the code window. The first difference is the current line pointer character, ASCII 16. This points to the line which will be executed as soon as the runtime module regains control of execution. The line pointer character is placed between the line's modifier and the actual text of the line. In the example above, the line pointer points to the final line in the code window. In practice, this character will be colored yellow to make it visible above the background. The second difference is the character on the far left of the line. This character indicates the current logical status of the line, X, for False, √ for True and ? for unknown. On start-up, all lines are assigned a value of unknown, but as the application executes, the lines' logical values are filled in. When a line is about to be executed, its status is set to unknown. Other than the differences from the editor noted above, the only features to be understood in the debugger are application step, trace and the function of watches and breakpoints. These are covered in the next four subsections. 7.3.1 Step When the application is stepped, the runtime module is given control of execution and it will run the line which was last hilited in the debugger's code window. RExL uses the <F8> keystroke to step. If the line was a statement, then it will be evaluated and the value returned will be assigned to the line's logical status as indicated by the character at the far left of the line. If the line was a rule, then the rule in its entirety will be executed and control returned when the rule has returned True or False to the caller. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 97 - If the line was a screen, then the screen will execute and return True. 7.3.2 Trace Trace works in the same manner as step does above, with one important difference: When you trace a rule, the debugger will expand the definition and place the debugger's hilite bar on the first non-blank line of the rule. <F7> or <Space> is used to trace a line. 7.3.3 Watch As explained above, a watch is an expression which is `watched' by both you and the debugger. The expression can be either string or numeric in type and is displayed in the watch window, underneath the code window. Watches are entered by pressing the <Ctrl-F7> key (or <Ctrl-W>). A dialog box appears, prompting for an expression to watch. The syntax will be checked and if valid, will be entered into the watch list. The format of the watch is simple: It consists of the expression entered, followed by a colon and a space, followed by the value of the expression you entered. If the cursor is placed over some alphanumeric symbol in your source, then that symbol will be entered in the dialog box. You can move the hilite bar to the watch window by pressing <F6>, although this will not be allowed if you do not have any watches in the watch window. When in the watch window, you can add new ones by pressing <Ctrl-F7> or <Ctrl-W> as before. Watches can be deleted by pressing <Del> or <Ctrl- Y> or <Alt-D>. Watches are more powerful (and dangerous) than they may at first seem: Since you are allowed to enter any expression as a watch, this may clearly include expressions like DBnext(), CLS() (and so on), functions which alter the status of RExL. Entering expressions such as these can have various unwanted side-effects in debugging sessions. The final point to note is that only those expressions which are visible in the watch window are actually evaluated at every cycle. You can have at most ten watches visible in the watch window at any one time. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 98 - 7.3.4 Expression Evaluate Expression evaluation is a `shortened' version of watching. It allows you to enter an expression and RExL will return the value of that expression either string or numeric. Evaluation, however, has one major difference from watching in that it allows you to enter a new value for an expression, if that expression is a valid LValue. [Figure not available in disk manual] When the expression evaluation box initially appears, the cursor will be in the Evaluate pane. If the cursor was placed on a word within the window, then that word will be pasted into the box. The expression which you want to be evaluated is then entered. The expression will then be syntax checked. If the syntax is not correct, then the you will be returned to the evaluate pane, otherwise the expression will be evaluated and the result displayed in the Result pane. If RExL has determined that the expression is a modifiable LValue, then the result of the expression will also be displayed in the New Value pane (whose border will change color), otherwise that pane will remain empty and the border color of the new value pane will remain unchanged. If the expression is an LValue, then you can press <Tab> to bring the cursor to the new value pane where you can enter a new value for the expression. This new value can be any valid expression which returns a result of the same type as the initial expression. Again, this expression is syntax checked and evaluated and the result is assigned to the expression in the evaluate pane. 7.3.5 Animation You can `animate' the execution of your application by pressing <Alt-F4>. During animation, the debugger simulates the pressing of the trace key at a definable interval. When you press <Alt-F4>, a numeric dialog box appears, prompting for an animate delay, measured in tenths of a second. This value can range from 0, where there will be no delay, to 600, where there will be a delay of one minute between successive steps. - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 99 - Press any key to stop the debugger animating the execution of the application. 7.3.6 To Here The debugger can execute an application to the current cursor line, `to here', when you press <F4>. This feature is sometimes known as temporary break-pointing, since the effect is to place a breakpoint at the line and run the application until either execution reaches a breakpoint, the application terminates or you press <Alt-D>: In any case, the breakpoint will be cleared. 7.4 Miscellaneous keystrokes <Ctrl-Home> moves the hilite bar to the top of the screen, while <Ctrl-End> moves it to the bottom of the screen or the last line in the rule, whichever is nearer. <Ctrl-PgUp> moves the hilite bar to the first line in the rule. <Alt-X> will attempt to terminate the debugger and return you to the editor, if the debugger was called from there. <F4> sets up a temporary breakpoint on the currently hilited line. <Ctrl-F4> and <Ctrl-E> bring up the expression evaluation box. <Alt-F5> displays the start-up screen of the editor. <Ctrl-F8> toggles a breakpoint at the current line. The breakpoint will be signalled by a breakpoint character, ■. <Alt-F4> animates the debugger. You will be prompted for an animation delay. <Ctrl-F7> and <Ctrl-W> enter a new watch expression. Entity lists are (as in the editor) as follows: - RExL Version 2.11 Copyright 1992, The Software Loft - - Main Manual. Page: 100 - Rule list: on <Alt-Z> and <Shift-F2> Screen list: on <Alt-S> and <Shift-F3> Unused rule list: on <Alt-U> and <Shift-F4> Unused screen list: on <Shift-F5> Variable list: on <Alt-V> and <Shift-F6> Function list: on <Ctrl-F> and <Shift-F7> 7.5 Command Line Parameters The debugger accepts the use of a number of command line parameters. These are letters (preceded by minus signs, -, or forward slashes /) which alter some internal default of the debugger. The current command line parameters are as follows: o -d: The `d' parameter will cause the debugger to start up in debug mode, as if the user had pressed <Alt-D> during loading of the application. This switch is passed invisibly by the editor to the debugger whenever the debugger is called via the Debug application option in the Run menu in the editor. o -e: The `e' option will return control to the editor when the debugger terminates. Whenever the editor calls the debugger, this option is silently passed to the debugger, so that the debugger will return to the editor when it terminates. o -k: This `k' option is used to tell the runtime module not to watch out for the two keystrokes of <Alt-D> and <Esc>, which are normally monitored. (<Alt-D> will interrupt the run module and relinquish control to the debugger while pressing <Esc> twice will terminate the application.) - RExL Version 2.11 Copyright 1992, The Software Loft -